event_result message_dispatcher::fire_on_syncevent(app& the_app, const system_event& se) { ANativeWindow *wnd; read(m_readfd, &wnd, sizeof(wnd)); LOGI("%s:%d> firing %s, wnd = %p\n", __FILE__, __LINE__, get_sys_event_name(se).c_str(), wnd); bool h = false; switch (se) { case system_event::window_created: h = the_app.on_window_created(app_window(wnd)); m_has_window = true; break; case system_event::window_destroyed: h = the_app.on_window_destroyed(app_window(wnd)); m_has_window = false; break; case system_event::window_exposed: h = the_app.on_window_exposed(app_window(wnd)); break; case system_event::window_resized: h = the_app.on_window_resized(app_window(wnd)); break; default: break; } m_syncevent.up(); return h ? event_result::handled : event_result::unhandled; }
int main() { // Create the main SFML window sf::RenderWindow app_window( sf::VideoMode( 800, 600 ), "SFGUI Image Example", sf::Style::Titlebar | sf::Style::Close ); // We have to do this because we don't use SFML to draw. app_window.resetGLStates(); // Create an SFGUI. This is required before doing anything with SFGUI. sfg::SFGUI sfgui; // Create our main SFGUI window sfg::Window::Ptr window; window = sfg::Window::Create(); window->SetTitle( "Title" ); // Our sf::Image source sf::Image sfgui_logo; // Our sfg::Image sfg::Image::Ptr image = sfg::Image::Create(); // Try to load the image if( sfgui_logo.loadFromFile( "data/sfgui.png" ) ) { image->SetImage( sfgui_logo ); } // Add the image to the window. window->Add( image ); // Start the game loop while ( app_window.isOpen() ) { // Process events sf::Event event; while ( app_window.pollEvent( event ) ) { // Handle events window->HandleEvent( event ); // Close window : exit if ( event.type == sf::Event::Closed ) { app_window.close(); } } // Update the GUI, note that you shouldn't normally // pass 0 seconds to the update method. window->Update( 0.f ); // Clear screen app_window.clear(); // Draw the GUI sfgui.Display( app_window ); // Update the window app_window.display(); } return EXIT_SUCCESS; }
int main() { // An sf::Window for raw OpenGL rendering. sf::Window app_window( sf::VideoMode( 800, 600 ), "SFGUI with OpenGL example", sf::Style::Titlebar | sf::Style::Close ); // Create an SFGUI. This is required before doing anything with SFGUI. sfg::SFGUI sfgui; // Set the SFML Window's context back to the active one. SFGUI creates // a temporary context on creation that is set active. app_window.setActive(); // Initial OpenGL setup. // We have to set up our own OpenGL viewport because we are using an sf::Window. glViewport( 0, 0, static_cast<int>( app_window.getSize().x ), static_cast<int>( app_window.getSize().y ) ); auto red_scale = sfg::Scale::Create( 0.f, 1.f, .01f, sfg::Scale::Orientation::HORIZONTAL ); auto green_scale = sfg::Scale::Create( 0.f, 1.f, .01f, sfg::Scale::Orientation::HORIZONTAL ); auto blue_scale = sfg::Scale::Create( 0.f, 1.f, .01f, sfg::Scale::Orientation::HORIZONTAL ); auto angle_scale = sfg::Scale::Create( 0.f, 360.f, 1.f, sfg::Scale::Orientation::HORIZONTAL ); auto auto_check = sfg::CheckButton::Create( "Auto" ); auto table = sfg::Table::Create(); table->SetRowSpacings( 5.f ); table->SetColumnSpacings( 5.f ); table->Attach( sfg::Label::Create( "Change the color of the rect using the scales below." ), sf::Rect<sf::Uint32>( 0, 0, 3, 1 ), sfg::Table::FILL, sfg::Table::FILL ); table->Attach( sfg::Label::Create( "Red:" ), sf::Rect<sf::Uint32>( 0, 1, 1, 1 ), sfg::Table::FILL, sfg::Table::FILL ); table->Attach( red_scale, sf::Rect<sf::Uint32>( 1, 1, 1, 1 ), sfg::Table::FILL | sfg::Table::EXPAND, sfg::Table::FILL | sfg::Table::EXPAND ); table->Attach( sfg::Label::Create( "Green:" ), sf::Rect<sf::Uint32>( 0, 2, 1, 1 ), sfg::Table::FILL, sfg::Table::FILL ); table->Attach( green_scale, sf::Rect<sf::Uint32>( 1, 2, 1, 1 ), sfg::Table::FILL | sfg::Table::EXPAND, sfg::Table::FILL | sfg::Table::EXPAND ); table->Attach( sfg::Label::Create( "Blue:" ), sf::Rect<sf::Uint32>( 0, 3, 1, 1 ), sfg::Table::FILL, sfg::Table::FILL ); table->Attach( blue_scale, sf::Rect<sf::Uint32>( 1, 3, 1, 1 ), sfg::Table::FILL | sfg::Table::EXPAND, sfg::Table::FILL | sfg::Table::EXPAND ); table->Attach( sfg::Label::Create( "Angle:" ), sf::Rect<sf::Uint32>( 0, 4, 1, 1 ), sfg::Table::FILL, sfg::Table::FILL ); table->Attach( angle_scale, sf::Rect<sf::Uint32>( 1, 4, 1, 1 ), sfg::Table::FILL | sfg::Table::EXPAND, sfg::Table::FILL | sfg::Table::EXPAND ); table->Attach( auto_check, sf::Rect<sf::Uint32>( 2, 4, 1, 1 ), sfg::Table::FILL, sfg::Table::FILL ); auto window = sfg::Window::Create(); window->SetTitle( "SFGUI with OpenGL" ); window->Add( table ); sfg::Desktop desktop; desktop.Add( window ); red_scale->SetValue( .2f ); green_scale->SetValue( .5f ); blue_scale->SetValue( .8f ); glMatrixMode( GL_PROJECTION ); glLoadIdentity(); static const auto pi = 3.1415926535897932384626433832795f; static const auto fov = 90.f; static const auto near_distance = .1f; static const auto far_distance = 100.f; static const auto aspect = 800.f / 600.f; auto frustum_height = std::tan( fov / 360 * pi ) * near_distance; auto frustum_width = frustum_height * aspect; glFrustum( -frustum_width, frustum_width, -frustum_height, frustum_height, near_distance, far_distance ); glMatrixMode( GL_MODELVIEW ); glLoadIdentity(); sf::Event event; sf::Clock clock; while( app_window.isOpen() ) { auto delta = clock.restart().asSeconds(); while( app_window.pollEvent( event ) ) { if( event.type == sf::Event::Closed ) { app_window.close(); } else { desktop.HandleEvent( event ); } } if( auto_check->IsActive() ) { float angle( angle_scale->GetValue() ); angle += delta * 90.f; while( angle >= 360.f ) { angle -= 360.f; } angle_scale->SetValue( angle ); } glClear( GL_COLOR_BUFFER_BIT ); glMatrixMode( GL_MODELVIEW ); glLoadIdentity(); glRotatef( angle_scale->GetValue(), 0.f, 0.f, 1.f ); glTranslatef( -.5f, -.5f, -5.f ); glBegin( GL_QUADS ); glColor3f( red_scale->GetValue(), green_scale->GetValue(), blue_scale->GetValue() ); glVertex3f( 0.f, 1.f, 0.f ); glVertex3f( 0.f, 0.f, 0.f ); glVertex3f( 1.f, 0.f, 0.f ); glVertex3f( 1.f, 1.f, 0.f ); glEnd(); desktop.Update( delta ); // SFGUI rendering. sfgui.Display( app_window ); app_window.display(); } return 0; }
int main() { // Create the main SFML window sf::RenderWindow app_window( sf::VideoMode( 800, 600 ), "SFGUI Layout Example", sf::Style::Titlebar | sf::Style::Close ); // We have to do this because we don't use SFML to draw. app_window.resetGLStates(); // Create an SFGUI. This is required before doing anything with SFGUI. sfg::SFGUI sfgui; // Create our main SFGUI window auto window = sfg::Window::Create(); window->SetTitle( "Resize me!" ); // Create a box with 20 pixels spacing. auto box = sfg::Box::Create( sfg::Box::Orientation::VERTICAL, 20.f ); // Create some buttons. auto button_aligned = sfg::Button::Create( "Aligned 0.8f right and bottom" ); auto button_fixed = sfg::Button::Create( "Fixed at (200, 50)" ); // Create a fixed. auto fixed = sfg::Fixed::Create(); // Add button_fixed to the fixed at (200, 50). fixed->Put( button_fixed, sf::Vector2f( 200.f, 50.f ) ); // Add our fixed to the box and set not to expand. box->Pack( fixed, false, true ); // Create a separator. auto separator = sfg::Separator::Create( sfg::Separator::Orientation::HORIZONTAL ); // Add separator to box and set not to expand. box->Pack( separator, false, true ); // Create an alignment. auto alignment = sfg::Alignment::Create(); // Because we want to align our button horizontally, we need // to place our alignment in a horizontal box set to expand and fill. auto alignment_box = sfg::Box::Create( sfg::Box::Orientation::HORIZONTAL ); alignment_box->Pack( alignment, true, true ); // Add button_aligned to the alignment. alignment->Add( button_aligned ); // Set scaling parameters. // Scaling sets how much of the total space in the alignment // the child gets to fill up. 1.0f for x and y would mean the // child gets to use the whole space. Setting it to 0.0f for // x and y makes the child get as little space as possible. alignment->SetScale( sf::Vector2f( .0f, .0f ) ); // Set alignment parameters. // Alignment aligns the child widget within the alignment's area. // 0.0f for x aligns to the left, 1.0f for x aligns to the right. // 0.0f for y aligns to the top, 1.0f for y aligns to the bottom. alignment->SetAlignment( sf::Vector2f( .8f, .8f ) ); // Create our frame. auto frame = sfg::Frame::Create( "Frame Title" ); // We can align the frame title just like an alignment. frame->SetAlignment( sf::Vector2f( .8f, .5f ) ); // Add our alignment box into the frame. frame->Add( alignment_box ); // Add our frame to the box. box->Pack( frame, true, true ); // Add the box to the window. window->Add( box ); // Start the game loop while ( app_window.isOpen() ) { // Process events sf::Event event; while ( app_window.pollEvent( event ) ) { // Handle events window->HandleEvent( event ); // Close window : exit if ( event.type == sf::Event::Closed ) { app_window.close(); } } // Update the GUI, note that you shouldn't normally // pass 0 seconds to the update method. window->Update( 0.f ); // Clear screen app_window.clear(); // Draw the GUI sfgui.Display( app_window ); // Update the window app_window.display(); } return EXIT_SUCCESS; }
void ScrolledWindowViewportExample::Run() { // Create the main SFML window sf::RenderWindow app_window( sf::VideoMode( 800, 600 ), "SFGUI ScrolledWindow and Viewport Example", sf::Style::Titlebar | sf::Style::Close ); // We have to do this because we don't use SFML to draw. app_window.resetGLStates(); // Create our main SFGUI window sfg::Window::Ptr window; window = sfg::Window::Create(); window->SetTitle( "Title" ); // Create a box with 10 pixel spacing. sfg::Box::Ptr box = sfg::Box::Create( sfg::Box::VERTICAL, 10.f ); // Create a button and connect the click signal. sfg::Button::Ptr button = sfg::Button::Create( "Add a button" ); button->GetSignal( sfg::Widget::OnLeftClick ).Connect( &ScrolledWindowViewportExample::OnButtonClick, this ); // Create a box for our ScrolledWindow. ScrolledWindows are bins // and can only contain 1 child widget. m_scrolled_window_box = sfg::Box::Create( sfg::Box::VERTICAL ); // Create the ScrolledWindow. sfg::ScrolledWindow::Ptr scrolledwindow = sfg::ScrolledWindow::Create(); // Set the ScrolledWindow to always show the horizontal scrollbar // and only show the vertical scrollbar when needed. scrolledwindow->SetScrollbarPolicy( sfg::ScrolledWindow::HORIZONTAL_ALWAYS | sfg::ScrolledWindow::VERTICAL_AUTOMATIC ); // Add the ScrolledWindow box to the ScrolledWindow // and create a new viewport automatically. scrolledwindow->AddWithViewport( m_scrolled_window_box ); // Always remember to set the minimum size of a ScrolledWindow. scrolledwindow->SetRequisition( sf::Vector2f( 500.f, 100.f ) ); // Create a viewport. sfg::Viewport::Ptr viewport = sfg::Viewport::Create(); // Always remember to set the minimum size of a Viewport. viewport->SetRequisition( sf::Vector2f( 500.f, 200.f ) ); // Set the vertical adjustment values of the Viewport. viewport->GetVerticalAdjustment()->SetLower( 0.f ); viewport->GetVerticalAdjustment()->SetUpper( 100000000.f ); // Create a box for our Viewport. Viewports are bins // as well and can only contain 1 child widget. sfg::Box::Ptr viewport_box = sfg::Box::Create( sfg::Box::VERTICAL ); sf::err() << "Generating random strings, please be patient..." << std::endl; // Create some random text. for( int i = 0; i < 200; i++ ) { std::string str; for( int j = 0; j < 20; j++ ) { str += static_cast<char>( 65 + rand() % 26 ); } // Add the text to the Viewport box. viewport_box->Pack( sfg::Label::Create( str.c_str() ) ); } // Add the Viewport box to the viewport. viewport->Add( viewport_box ); // Add everything to our box. box->Pack( button, false, true ); box->Pack( scrolledwindow, false, true ); box->Pack( viewport, true, true ); // Add the box to the window. window->Add( box ); sf::Clock clock; // Start the game loop while ( app_window.isOpen() ) { // Process events sf::Event event; while ( app_window.pollEvent( event ) ) { // Handle events window->HandleEvent( event ); // Close window : exit if ( event.type == sf::Event::Closed ) { app_window.close(); } } // Update the GUI every 1ms if( clock.getElapsedTime().asMicroseconds() >= 1000 ) { float delta = static_cast<float>( clock.getElapsedTime().asMicroseconds() ) / 1000000.f; // Update() takes the elapsed time in seconds. window->Update( delta ); // Add a nice automatic scrolling effect to our viewport ;) viewport->GetVerticalAdjustment()->SetValue( viewport->GetVerticalAdjustment()->GetValue() + delta * 10.f ); clock.restart(); } // Clear screen app_window.clear(); // Draw the GUI m_sfgui.Display( app_window ); // Update the window app_window.display(); } }
int main() { // An sf::Window for raw OpenGL rendering. sf::Window app_window( sf::VideoMode( 800, 600 ), "SFGUI with OpenGL example", sf::Style::Titlebar | sf::Style::Close ); // Create an SFGUI. This is required before doing anything with SFGUI. sfg::SFGUI sfgui; // Set the SFML Window's context back to the active one. SFGUI creates // a temporary context on creation that is set active. app_window.setActive(); // Initial OpenGL setup. // We have to set up our own OpenGL viewport because we are using an sf::Window. glViewport( 0, 0, app_window.getSize().x, app_window.getSize().y ); sfg::Scale::Ptr red_scale( sfg::Scale::Create( 0.f, 1.f, .01f, sfg::Scale::HORIZONTAL ) ); sfg::Scale::Ptr green_scale( sfg::Scale::Create( 0.f, 1.f, .01f, sfg::Scale::HORIZONTAL ) ); sfg::Scale::Ptr blue_scale( sfg::Scale::Create( 0.f, 1.f, .01f, sfg::Scale::HORIZONTAL ) ); sfg::Scale::Ptr angle_scale( sfg::Scale::Create( 0.f, 360.f, 1.f, sfg::Scale::HORIZONTAL ) ); sfg::CheckButton::Ptr auto_check( sfg::CheckButton::Create( "Auto" ) ); sfg::Table::Ptr table( sfg::Table::Create() ); table->SetRowSpacings( 5.f ); table->SetColumnSpacings( 5.f ); table->Attach( sfg::Label::Create( "Change the color of the rect using the scales below." ), sf::Rect<sf::Uint32>( 0, 0, 3, 1 ), sfg::Table::FILL, sfg::Table::FILL ); table->Attach( sfg::Label::Create( "Red:" ), sf::Rect<sf::Uint32>( 0, 1, 1, 1 ), sfg::Table::FILL, sfg::Table::FILL ); table->Attach( red_scale, sf::Rect<sf::Uint32>( 1, 1, 1, 1 ), sfg::Table::FILL | sfg::Table::EXPAND, sfg::Table::FILL | sfg::Table::EXPAND ); table->Attach( sfg::Label::Create( "Green:" ), sf::Rect<sf::Uint32>( 0, 2, 1, 1 ), sfg::Table::FILL, sfg::Table::FILL ); table->Attach( green_scale, sf::Rect<sf::Uint32>( 1, 2, 1, 1 ), sfg::Table::FILL | sfg::Table::EXPAND, sfg::Table::FILL | sfg::Table::EXPAND ); table->Attach( sfg::Label::Create( "Blue:" ), sf::Rect<sf::Uint32>( 0, 3, 1, 1 ), sfg::Table::FILL, sfg::Table::FILL ); table->Attach( blue_scale, sf::Rect<sf::Uint32>( 1, 3, 1, 1 ), sfg::Table::FILL | sfg::Table::EXPAND, sfg::Table::FILL | sfg::Table::EXPAND ); table->Attach( sfg::Label::Create( "Angle:" ), sf::Rect<sf::Uint32>( 0, 4, 1, 1 ), sfg::Table::FILL, sfg::Table::FILL ); table->Attach( angle_scale, sf::Rect<sf::Uint32>( 1, 4, 1, 1 ), sfg::Table::FILL | sfg::Table::EXPAND, sfg::Table::FILL | sfg::Table::EXPAND ); table->Attach( auto_check, sf::Rect<sf::Uint32>( 2, 4, 1, 1 ), sfg::Table::FILL, sfg::Table::FILL ); sfg::Window::Ptr window( sfg::Window::Create() ); window->SetTitle( "SFGUI with OpenGL" ); window->Add( table ); sfg::Desktop desktop; desktop.Add( window ); red_scale->SetValue( .2f ); green_scale->SetValue( .5f ); blue_scale->SetValue( .8f ); glMatrixMode( GL_PROJECTION ); glLoadIdentity(); gluPerspective( 90.f, 800.f / 600.f, .1f, 100.f ); glMatrixMode( GL_MODELVIEW ); glLoadIdentity(); sf::Event event; sf::Clock clock; while( app_window.isOpen() ) { while( app_window.pollEvent( event ) ) { if( event.type == sf::Event::Closed ) { app_window.close(); } else { desktop.HandleEvent( event ); } } if( auto_check->IsActive() ) { float angle( angle_scale->GetValue() ); angle += static_cast<float>( clock.getElapsedTime().asMicroseconds() ) * .0005f; while( angle >= 360.f ) { angle -= 360.f; } angle_scale->SetValue( angle ); } glClear( GL_COLOR_BUFFER_BIT ); glMatrixMode( GL_MODELVIEW ); glLoadIdentity(); glRotatef( angle_scale->GetValue(), 0.f, 0.f, 1.f ); glTranslatef( -.5f, -.5f, -5.f ); glBegin( GL_QUADS ); glColor3f( red_scale->GetValue(), green_scale->GetValue(), blue_scale->GetValue() ); glVertex3f( 0.f, 1.f, 0.f ); glVertex3f( 0.f, 0.f, 0.f ); glVertex3f( 1.f, 0.f, 0.f ); glVertex3f( 1.f, 1.f, 0.f ); glEnd(); desktop.Update( clock.restart().asSeconds() ); // SFGUI rendering. sfgui.Display( app_window ); app_window.display(); clock.restart(); } return 0; }
int main() { // Create the main SFML window sf::RenderWindow app_window( sf::VideoMode( 800, 600 ), "SFGUI Canvas Example", sf::Style::Titlebar | sf::Style::Close ); // We have to do this because we don't use SFML to draw. app_window.resetGLStates(); // Create an SFGUI. This is required before doing anything with SFGUI. sfg::SFGUI sfgui; // Create our OpenGL canvas window sfg::Window::Ptr opengl_window; opengl_window = sfg::Window::Create(); opengl_window->SetTitle( "OpenGL canvas" ); opengl_window->SetPosition( sf::Vector2f( 100.f, 100.f ) ); // Create our SFML canvas window sfg::Window::Ptr sfml_window; sfml_window = sfg::Window::Create(); sfml_window->SetTitle( "SFML canvas" ); sfml_window->SetPosition( sf::Vector2f( 400.f, 100.f ) ); // Create our Canvas smart pointers. sfg::Canvas::Ptr opengl_canvas; sfg::Canvas::Ptr sfml_canvas; // Create the Canvases themselves. // Passing true in to Create() tells SFGUI // to create a depth buffer for the canvas. // This might be needed for your OpenGL rendering. // Specifying nothing defaults to no depth buffer. opengl_canvas = sfg::Canvas::Create( true ); sfml_canvas = sfg::Canvas::Create(); // Add the Canvases to the windows. opengl_window->Add( opengl_canvas ); sfml_window->Add( sfml_canvas ); // Create an sf::Sprite for demonstration purposes. sf::Texture texture; texture.loadFromFile( "data/sfgui.png" ); sf::Sprite sprite; sprite.setTexture( texture ); // Because Canvases provide a virtual surface to draw // on much like a ScrolledWindow, specifying their // minimum requisition is necessary. opengl_canvas->SetRequisition( sf::Vector2f( 200.f, 150.f ) ); sfml_canvas->SetRequisition( sf::Vector2f( texture.getSize() ) ); // Create a desktop to contain our Windows. sfg::Desktop desktop; desktop.Add( opengl_window ); desktop.Add( sfml_window ); sf::Clock clock; // Start the game loop while ( app_window.isOpen() ) { // Process events sf::Event event; while ( app_window.pollEvent( event ) ) { // Handle events desktop.HandleEvent( event ); // Close window : exit if ( event.type == sf::Event::Closed ) { app_window.close(); } } // Update the GUI, note that you shouldn't normally // pass 0 seconds to the update method. desktop.Update( 0.f ); // Clear screen app_window.clear(); // We bind the Canvases and draw whatever we want to them. // This must occur BEFORE the GUI is displayed. // You must not forget to set whatever context was active // before to active again after you unbind a Canvas. // Clear() takes an RGBA color and a bool which specifies // if you want to clear the depth buffer as well. In this // case, we do. // First the Canvas for OpenGL rendering. opengl_canvas->Bind(); opengl_canvas->Clear( sf::Color( 0, 0, 0, 0 ), true ); // Do some OpenGL drawing. If you don't intend // on drawing with OpenGL just ignore this section. glEnable( GL_DEPTH_TEST ); glDepthMask( GL_TRUE ); glDisable( GL_TEXTURE_2D ); glMatrixMode( GL_MODELVIEW ); glPushMatrix(); glLoadIdentity(); glTranslatef( 0.f, 0.f, -2.f ); glRotatef( clock.getElapsedTime().asSeconds() * 30.f, 0.f, 0.f, 1.f ); glDisable( GL_TEXTURE_2D ); glMatrixMode( GL_PROJECTION ); glPushMatrix(); glLoadIdentity(); glViewport( 0, 0, static_cast<int>( opengl_canvas->GetAllocation().width ), static_cast<int>( opengl_canvas->GetAllocation().height ) ); gluPerspective( 90.f, opengl_canvas->GetAllocation().width / opengl_canvas->GetAllocation().height, 1.f, 20.f ); glBegin( GL_QUADS ); glVertex2s( -1, 1 ); glVertex2s( -1, -1 ); glVertex2s( 1, -1 ); glVertex2s( 1, 1 ); glEnd(); glPopMatrix(); glMatrixMode( GL_MODELVIEW ); glPopMatrix(); glViewport( 0, 0, app_window.getSize().x, app_window.getSize().y ); glEnable( GL_TEXTURE_2D ); glDisable( GL_DEPTH_TEST ); opengl_canvas->Display(); opengl_canvas->Unbind(); // Then the Canvas for SFML rendering. sfml_canvas->Bind(); sfml_canvas->Clear( sf::Color( 0, 0, 0, 0 ) ); // Draw the SFML Sprite. sfml_canvas->Draw( sprite ); sfml_canvas->Display(); sfml_canvas->Unbind(); // This is important. app_window.setActive( true ); // Draw the GUI sfgui.Display( app_window ); // Update the window app_window.display(); } return EXIT_SUCCESS; }
int main() { // Create the main SFML window sf::RenderWindow app_window( sf::VideoMode( 800, 600 ), "SFGUI Combo Box Example", sf::Style::Titlebar | sf::Style::Close ); // Construct our SFML guard // See http://sfgui.sfml-dev.de/forum/topic52-crash-on-close.html for more info. sfg::SFGUI sfgui; // Create our main SFGUI window sfg::Window::Ptr window; window = sfg::Window::Create(); window->SetTitle( "Title" ); // Create the combo box itself. combo_box = sfg::ComboBox::Create(); // Set the entries of the combo box. combo_box->AppendItem( "Bar" ); combo_box->PrependItem( "Foo" ); sel_label = sfg::Label::Create( L"Please select an item!" ); sfg::Button::Ptr button( sfg::Button::Create( L"Add item" ) ); sfg::Box::Ptr hbox( sfg::Box::Create( sfg::Box::HORIZONTAL, 5 ) ); hbox->Pack( combo_box ); hbox->Pack( button, false ); sfg::Box::Ptr vbox( sfg::Box::Create( sfg::Box::VERTICAL, 5 ) ); vbox->Pack( hbox, false ); vbox->Pack( sel_label, true ); // Add the combo box to the window window->Add( vbox ); // So that our combo box has a meaningful purpose (besides just looking // awesome :P) we need to tell it to connect to a callback of our choosing to // notify us when it is clicked. combo_box->OnSelect.Connect( &OnComboSelect ); button->OnClick.Connect( &OnAddItemClick ); // If attempting to connect to a class method you need to provide // a pointer to it as the second parameter after the function address. // Start the game loop while ( app_window.isOpen() ) { // Process events sf::Event event; while ( app_window.pollEvent( event ) ) { // Handle events window->HandleEvent( event ); // Close window : exit if ( event.type == sf::Event::Closed ) { app_window.close(); } } // Update the GUI, note that you shouldn't normally // pass 0 seconds to the update method. window->Update( 0.f ); // Clear screen app_window.clear(); // Draw the GUI sfg::Renderer::Get().Display( app_window ); // Update the window app_window.display(); } // If you have any global or static widgets, // you need to reset their pointers before your // application exits. combo_box.reset(); sel_label.reset(); return EXIT_SUCCESS; }
void EntryExample::Run() { // Create the main SFML window sf::RenderWindow app_window( sf::VideoMode( 800, 600 ), "SFGUI Entry Example", sf::Style::Titlebar | sf::Style::Close ); // We have to do this because we don't use SFML to draw. app_window.resetGLStates(); // Create our main SFGUI window auto window = sfg::Window::Create(); window->SetTitle( "Title" ); // Create our box. auto box = sfg::Box::Create( sfg::Box::Orientation::HORIZONTAL ); // Create a button. auto button = sfg::Button::Create(); button->SetLabel( "Set" ); // Connect the button. button->GetSignal( sfg::Widget::OnLeftClick ).Connect( std::bind( &EntryExample::ButtonClick, this ) ); // Create a label. m_label = sfg::Label::Create(); m_label->SetText( "no text yet" ); // Create our entry widget itself. m_entry = sfg::Entry::Create(); // Until now all widgets only expanded to fit the text inside of it. // This is not the case with the entry widget which can be empty // but still has to have a reasonable size. // To disable the automatic sizing of widgets in general you can // use the SetRequisition() method. it takes an sf::Vector as it's // parameter. Depending on which side you want to have a minimum size, // you set the corresponding value in the vector. // Here we chose to set the minimum x size of the widget to 80. m_entry->SetRequisition( sf::Vector2f( 80.f, 0.f ) ); // Setting sizing back to automatic is as easy as setting // x and y sizes to 0. // Pack into box box->Pack( m_entry ); box->Pack( button ); box->Pack( m_label ); // Set box spacing box->SetSpacing( 5.f ); // Add our box to the window window->Add( box ); sf::Clock clock; // Update an initial time to construct the GUI before drawing begins. // This makes sure that there are no frames in which no GUI is visible. window->Update( 0.f ); // Start the game loop while ( app_window.isOpen() ) { // Process events sf::Event event; while ( app_window.pollEvent( event ) ) { // Handle events window->HandleEvent( event ); // Close window : exit if ( event.type == sf::Event::Closed ) { app_window.close(); } } // Update the GUI every 5ms if( clock.getElapsedTime().asMicroseconds() >= 5000 ) { // Update() takes the elapsed time in seconds. window->Update( static_cast<float>( clock.getElapsedTime().asMicroseconds() ) / 1000000.f ); clock.restart(); } // Clear screen app_window.clear(); // Draw the GUI m_sfgui.Display( app_window ); // Update the window app_window.display(); } }
int main() { // Create the main SFML window sf::RenderWindow app_window( sf::VideoMode( 800, 600 ), "SFGUI Entry Example" ); // Create our main SFGUI window sfg::Window::Ptr window; window = sfg::Window::Create(); window->SetTitle( "Title" ); // Create our box. sfg::Box::Ptr box = sfg::Box::Create( sfg::Box::Horizontal ); // Create a button. sfg::Button::Ptr button = sfg::Button::Create(); button->SetLabel( "Set" ); // Connect the button. button->OnClick.Connect( &ButtonClick ); // Create a label. label = sfg::Label::Create(); label->SetText( "no text yet" ); // Create our entry widget itself. entry = sfg::Entry::Create(); // Until now all widgets only expanded to fit the text inside of it. // This is not the case with the entry widget which can be empty // but still has to have a reasonable size. // To disable the automatic sizing of widgets in general you can // use the SetRequisition() method. it takes an sf::Vector as it's // parameter. Depending on which side you want to have a minimum size, // you set the corresponding value in the vector. // Here we chose to set the minimum x size of the widget to 80. entry->SetRequisition( sf::Vector2f( 80.f, 0.f ) ); // Setting sizing back to automatic is as easy as setting // x and y sizes to 0. // Pack into box box->Pack( entry ); box->Pack( button ); box->Pack( label ); // Set box spacing box->SetSpacing( 5.f ); // Add our box to the window window->Add( box ); window->SetBorderWidth( 10.f ); // Start the game loop while ( app_window.IsOpened() ) { // Process events sf::Event event; while ( app_window.PollEvent( event ) ) { // Handle events window->HandleEvent( event ); // Close window : exit if( (event.Type == sf::Event::Closed) || (event.Type == sf::Event::KeyPressed && event.Key.Code == sf::Keyboard::Escape) ) { app_window.Close(); } } // Clear screen app_window.Clear(); // Draw the window window->Expose( app_window ); // Update the window app_window.Display(); } return EXIT_SUCCESS; }
void Application::Run() { sf::RenderWindow app_window( sf::VideoMode( 800, 600 ), "SFGUI Button Example", sf::Style::Titlebar | sf::Style::Close ); // We have to do this because we don't use SFML to draw. app_window.resetGLStates(); window = sfg::Window::Create(); window->SetTitle( "Title" ); sfg::Box::Ptr box = sfg::Box::Create( sfg::Box::VERTICAL ); window->Add( box ); // Possibility 1, normal function sfg::Button::Ptr button1 = sfg::Button::Create(); button1->SetLabel( "Clicky 1" ); button1->OnLeftClick.Connect( &Foo ); box->Pack( button1, false ); // Possibility 2, this class sfg::Button::Ptr button2 = sfg::Button::Create(); button2->SetLabel( "Clicky 2" ); button2->OnLeftClick.Connect( &Application::Bar, this ); box->Pack( button2, false ); // Possibility 3, objects BazClass baz_array[3] = { BazClass( 1 ), BazClass( 2 ), BazClass( 3 ) }; for( int i = 0; i < 3; i++ ) { std::stringstream sstr; sstr << "Clicky " << i + 3; sfg::Button::Ptr button = sfg::Button::Create(); button->SetLabel( sstr.str() ); // This is just a more complicated way of passing a pointer to a // BazClass to Connect() when the BazClass object is part of an array. // Passing normal pointers such as &baz1 would also work. button->OnLeftClick.Connect( &BazClass::Baz, &( baz_array[i] ) ); box->Pack( button, false ); } // Notice that with possibility 3 you can do very advanced things. The tricky // part of implementing it this way is that the method address has to be // known at compile time, which means that only the instanciated object itself // is able to pick how it will behave when that method is called on it. This // way you can also connect signals to dynamically determined behavior. // For further reading on this topic refer to Design Patterns and as // specialized cases similar to the one in this example the // Factory Method Pattern and Abstract Factory Pattern. while ( app_window.isOpen() ) { sf::Event event; while ( app_window.pollEvent( event ) ) { window->HandleEvent( event ); if ( event.type == sf::Event::Closed ) { app_window.close(); } } // Update the GUI, note that you shouldn't normally // pass 0 seconds to the update method. window->Update( 0.f ); // Clear screen app_window.clear(); // Draw the GUI m_sfgui.Display( app_window ); // Update the window app_window.display(); } // If you have any global or static widgets, // you need to reset their pointers before your // application exits. window.reset(); }
int main() { // Create the main SFML window sf::RenderWindow app_window( sf::VideoMode( 800, 600 ), "SFGUI Range Example" ); // Create our main SFGUI window sfg::Window::Ptr window; window = sfg::Window::Create(); window->SetTitle( "Title" ); // Create our box. sfg::Box::Ptr box = sfg::Box::Create( sfg::Box::Horizontal ); // Create a label. label = sfg::Label::Create(); label->SetText( "20" ); // Scale and Scrollbar widgets are subclasses of the Range class. // They have a common data representation object known as an // Adjustment. The Adjustment that each range widget is bound to // determines it's current state (where the slider is, what max // and min values are, how much to scroll per step etc.). Because // range widgets share this common data object they can also be // linked together by a common Adjustment instance. An Adjustment // is created automatically for you when you create a range widget. // Create our scale smart pointer. sfg::Scale::Ptr scale; // Create the scale itself. // We want a horizontal scale. scale = sfg::Scale::Create( sfg::Scale::Horizontal ); // Create our scrollbar smart pointer. sfg::Scrollbar::Ptr scrollbar; // Create the scrollbar itself. // We want a vertical scrollbar. scrollbar = sfg::Scrollbar::Create( sfg::Scrollbar::Vertical ); // We can link both widgets together by their adjustments. adjustment = scrollbar->GetAdjustment(); scale->SetAdjustment( adjustment ); // Tune the adjustment parameters. adjustment->SetLower( 20.f ); adjustment->SetUpper( 100.f ); // How much it should change when clicked on the stepper. adjustment->SetMinorStep( 3.f ); // How much it should change when clicked on the trough. adjustment->SetMajorStep( 12.f ); // CAUTION: // Normally you would only set the page size for scrollbar adjustments. // For demonstration purposes we do this for our scale widget too. // If page size isn't 0 a scale widget won't be able to be set to it's // maximum value. This is in fact also true for scrollbars, however // because they are used to scroll the page size must be subtracted from // the maximum. adjustment->SetPageSize( 20.f ); // Additionally you can connect to the OnChange signal of an adjustment // to get notified when any of it's parameters are changed. adjustment->OnChange.Connect( &AdjustmentChange ); // Just as with the entry widget we set custom requisitions for our // range widgets to make sure they don't look strange. scale->SetRequisition( sf::Vector2f( 80.f, 20.f ) ); scrollbar->SetRequisition( sf::Vector2f( 0.f, 80.f ) ); // To keep our scale's slider from expanding too much we use another box // set to verticle orientation. sfg::Box::Ptr scalebox = sfg::Box::Create( sfg::Box::Vertical ); scalebox->Pack( scale, false, false ); // Pack into box box->Pack( scalebox ); box->Pack( scrollbar ); box->Pack( label ); // Set box spacing box->SetSpacing( 5.f ); // Add our box to the window window->Add( box ); window->SetBorderWidth( 10.f ); // Start the game loop while ( app_window.IsOpened() ) { // Process events sf::Event event; while ( app_window.PollEvent( event ) ) { // Handle events window->HandleEvent( event ); // Close window : exit if( (event.Type == sf::Event::Closed) || (event.Type == sf::Event::KeyPressed && event.Key.Code == sf::Keyboard::Escape) ) { app_window.Close(); } } // Clear screen app_window.Clear(); // Draw the window window->Expose( app_window ); // Update the window app_window.Display(); } return EXIT_SUCCESS; }
int main() { // Create the main SFML window sf::RenderWindow app_window( sf::VideoMode( 800, 600 ), "SFGUI Window Example", sf::Style::Titlebar | sf::Style::Close ); // We have to do this because we don't use SFML to draw. app_window.resetGLStates(); // Create an SFGUI. This is required before doing anything with SFGUI. sfg::SFGUI sfgui; // Create our main SFGUI window // Almost everything in SFGUI is handled through smart pointers // for automatic resource management purposes. You create them // and they will automatically be destroyed when the time comes. sfg::Window::Ptr window; // Here we do the actual creation of the window. Creation of // widgets is always done with it's Create() method. window = sfg::Window::Create(); // Here we can set the window's title bar text. window->SetTitle( "A really really really really long title" ); // For more things to set around the window refer to the // API documentation. // Start the game loop while ( app_window.isOpen() ) { // Process events sf::Event event; while ( app_window.pollEvent( event ) ) { // Every frame we have to send SFML events to the window // to enable user interactivity. Without doing this your // GUI is nothing but a big colorful picture ;) window->HandleEvent( event ); // Close window : exit if ( event.type == sf::Event::Closed ) { app_window.close(); } } // Update the GUI, note that you shouldn't normally // pass 0 seconds to the update method. window->Update( 0.f ); // Clear screen app_window.clear(); // After drawing the rest of your game, you have to let the GUI // render itself. If you don't do this you will never be able // to see it ;) sfgui.Display( app_window ); // NOTICE // Because the window doesn't have any children it will shrink to // it's minimum size of (0,0) resulting in you not seeing anything // except the title bar text ;) Don't worry, in the Label example // you'll get to see more. // Update the window app_window.display(); } return EXIT_SUCCESS; }
void ButtonsExample::Run() { // Create the main SFML window sf::RenderWindow app_window( sf::VideoMode( 800, 600 ), "SFGUI Buttons Example", sf::Style::Titlebar | sf::Style::Close ); // We have to do this because we don't use SFML to draw. app_window.resetGLStates(); // Create our main SFGUI window m_window = sfg::Window::Create(); m_window->SetTitle( "Title" ); // Create a Box to contain all our fun buttons ;) sfg::Box::Ptr box = sfg::Box::Create( sfg::Box::VERTICAL, 5.f ); // Create the Button itself. m_button = sfg::Button::Create( "Click me" ); // Add the Button to the Box box->Pack( m_button ); // So that our Button has a meaningful purpose // (besides just looking awesome :P) we need to tell it to connect // to a callback of our choosing to notify us when it is clicked. m_button->GetSignal( sfg::Widget::OnLeftClick ).Connect( &ButtonsExample::ButtonClick, this ); // If attempting to connect to a class method you need to provide // a pointer to it as the second parameter after the function address. // Refer to the Signals example for more information. // Create the ToggleButton itself. m_toggle_button = sfg::ToggleButton::Create( "Toggle me" ); // Connect the OnToggle signal to our handler. m_toggle_button->GetSignal( sfg::ToggleButton::OnToggle ).Connect( &ButtonsExample::ButtonToggle, this ); // Add the ToggleButton to the Box box->Pack( m_toggle_button ); // Create the CheckButton itself. m_check_button = sfg::CheckButton::Create( "Check me" ); // Since a CheckButton is also a ToggleButton we can use // ToggleButton signals to handle events for CheckButtons. m_check_button->GetSignal( sfg::ToggleButton::OnToggle ).Connect( &ButtonsExample::ButtonCheck, this ); // Add the CheckButton to the Box box->Pack( m_check_button ); // Just to keep things tidy ;) box->Pack( sfg::Separator::Create() ); // Create our RadioButtons. // RadioButtons each have a group they belong to. If not specified, // a new group is created by default for each RadioButton. You can // then use RadioButton::SetGroup() to set the group of a RadioButton // after you create them. If you already know which buttons will belong // to the same group you can just pass the group of the first button // to the following buttons when you construct them as we have done here. m_radio_button1 = sfg::RadioButton::Create( "Either this" ); m_radio_button2 = sfg::RadioButton::Create( "Or this", m_radio_button1->GetGroup() ); m_radio_button3 = sfg::RadioButton::Create( "Or maybe even this", m_radio_button1->GetGroup() ); // Set the third RadioButton to be the active one. // By default none of the RadioButtons are active at start. m_radio_button3->SetActive( true ); // Here we use the same handler for all three RadioButtons. // RadioButtons are CheckButtons and therefore also ToggleButtons, // hence we can use ToggleButton signals with RadioButtons as well. m_radio_button1->GetSignal( sfg::ToggleButton::OnToggle ).Connect( &ButtonsExample::ButtonSelect, this ); m_radio_button2->GetSignal( sfg::ToggleButton::OnToggle ).Connect( &ButtonsExample::ButtonSelect, this ); m_radio_button3->GetSignal( sfg::ToggleButton::OnToggle ).Connect( &ButtonsExample::ButtonSelect, this ); // Add the RadioButtons to the Box box->Pack( m_radio_button1 ); box->Pack( m_radio_button2 ); box->Pack( m_radio_button3 ); // Finally add the Box to the window. m_window->Add( box ); // Start the game loop while ( app_window.isOpen() ) { // Process events sf::Event event; while ( app_window.pollEvent( event ) ) { // Handle events m_window->HandleEvent( event ); // Close window : exit if ( event.type == sf::Event::Closed ) { app_window.close(); } } // Update the GUI, note that you shouldn't normally // pass 0 seconds to the update method. m_window->Update( 0.f ); // Clear screen app_window.clear(); // Draw the GUI m_sfgui.Display( app_window ); // Update the window app_window.display(); } }
int main() { // Create the main SFML window sf::RenderWindow app_window( sf::VideoMode( 800, 600 ), "SFGUI Box Example", sf::Style::Titlebar | sf::Style::Close ); // Construct our SFML guard // See http://sfgui.sfml-dev.de/forum/topic52-crash-on-close.html for more info. sfg::SFGUI sfgui; // Create our main SFGUI window sfg::Window::Ptr window; window = sfg::Window::Create(); window->SetTitle( "Title" ); // Since only being able to add one widget to a window is very limiting // there are Box widgets. They are a subclass of the Container class and // can contain an unlimited amount of child widgets. Not only that, they // also have the ability to lay out your widgets nicely. // Create our box smart pointer. sfg::Box::Ptr box; // Create the box itself. // For layout purposes we must specify in what direction new widgets // should be added, horizontally or vertically. box = sfg::Box::Create( sfg::Box::HORIZONTAL ); sfg::Button::Ptr button1 = sfg::Button::Create(); sfg::Button::Ptr button2 = sfg::Button::Create(); sfg::Label::Ptr label = sfg::Label::Create(); button1->SetLabel( "Foo" ); button2->SetLabel( "Bar" ); label->SetText( "Baz" ); // To add our widgets to the box we use the Pack() method instead of the // Add() method. This makes sure the widgets are added and layed out // properly in the box. box->Pack( button1 ); box->Pack( label ); box->Pack( button2 ); // Just as with the window we can set the spacing between widgets // withing a box. box->SetSpacing( 5.f ); // Finally we add our box to the window as it's only child. // Notice that we don't have to add the children of a box to it's parent // Because all children and grandchildren and .... are automatically // considered descendents of the parent. window->Add( box ); // Start the game loop while ( app_window.isOpen() ) { // Process events sf::Event event; while ( app_window.pollEvent( event ) ) { // Handle events window->HandleEvent( event ); // Close window : exit if ( event.type == sf::Event::Closed ) { app_window.close(); } } // Update the GUI, note that you shouldn't normally // pass 0 seconds to the update method. window->Update( 0.f ); // Clear screen app_window.clear(); // Draw the GUI sfg::Renderer::Get().Display( app_window ); // Update the window app_window.display(); } return EXIT_SUCCESS; }
void SpinnerExample::Run() { // Create the main SFML window sf::RenderWindow app_window( sf::VideoMode( 800, 600 ), "SFGUI Spinner Example", sf::Style::Titlebar | sf::Style::Close ); // We have to do this because we don't use SFML to draw. app_window.resetGLStates(); // Create our main SFGUI window auto window = sfg::Window::Create(); window->SetTitle( "Title" ); // Create our spinner m_spinner = sfg::Spinner::Create(); // Set how big the spinner should be m_spinner->SetRequisition( sf::Vector2f( 40.f, 40.f ) ); // Create a button and connect the click signal. auto button = sfg::Button::Create( "Toggle" ); button->GetSignal( sfg::Widget::OnLeftClick ).Connect( std::bind( &SpinnerExample::OnButtonClick, this ) ); // Create a horizontal box layouter and add widgets to it. auto box = sfg::Box::Create( sfg::Box::Orientation::HORIZONTAL, 5.0f ); box->Pack( m_spinner ); box->Pack( button, false ); // Add the box to the window. window->Add( box ); // Our clock to make the spinner spin ;) sf::Clock clock; // Update an initial time to construct the GUI before drawing begins. // This makes sure that there are no frames in which no GUI is visible. window->Update( 0.f ); // Start the game loop while ( app_window.isOpen() ) { // Process events sf::Event event; while ( app_window.pollEvent( event ) ) { // Handle events window->HandleEvent( event ); // Close window : exit if ( event.type == sf::Event::Closed ) { app_window.close(); } } // Update the GUI every 5ms if( clock.getElapsedTime().asMicroseconds() >= 5000 ) { // Update() takes the elapsed time in seconds. window->Update( static_cast<float>( clock.getElapsedTime().asMicroseconds() ) / 1000000.f ); clock.restart(); } // Clear screen app_window.clear(); // Draw the GUI m_sfgui.Display( app_window ); // Update the window app_window.display(); } }
void ProgressBarExample::Run() { // Create the main SFML window sf::RenderWindow app_window( sf::VideoMode( 800, 600 ), "SFGUI Progress Bar Example", sf::Style::Titlebar | sf::Style::Close ); // We have to do this because we don't use SFML to draw. app_window.resetGLStates(); // Create our main SFGUI window sfg::Window::Ptr window; window = sfg::Window::Create(); window->SetTitle( "Title" ); // Create our progress bar m_progressbar = sfg::ProgressBar::Create(); // Set how big the progress bar should be m_progressbar->SetRequisition( sf::Vector2f( 200.f, 40.f ) ); // Create a button and connect the click signal. sfg::Button::Ptr button( sfg::Button::Create( "Set Random Value" ) ); button->GetSignal( sfg::Widget::OnLeftClick ).Connect( &ProgressBarExample::OnButtonClick, this ); // Create a horizontal box layouter and add widgets to it. sfg::Box::Ptr box( sfg::Box::Create( sfg::Box::HORIZONTAL, 5.0f ) ); box->Pack( m_progressbar ); box->Pack( button, false ); // Add the box to the window. window->Add( box ); // Our clock sf::Clock clock; // Start the game loop while ( app_window.isOpen() ) { // Process events sf::Event event; while ( app_window.pollEvent( event ) ) { // Handle events window->HandleEvent( event ); // Close window : exit if ( event.type == sf::Event::Closed ) { app_window.close(); } } // Update the GUI every 5ms if( clock.getElapsedTime().asMicroseconds() >= 5000 ) { // Update() takes the elapsed time in seconds. window->Update( static_cast<float>( clock.getElapsedTime().asMicroseconds() ) / 1000000.f ); clock.restart(); } // Clear screen app_window.clear(); // Draw the GUI m_sfgui.Display( app_window ); // Update the window app_window.display(); } }
void ComboBoxExample::Run() { // Create the main SFML window sf::RenderWindow app_window( sf::VideoMode( 800, 600 ), "SFGUI Combo Box Example", sf::Style::Titlebar | sf::Style::Close ); // We have to do this because we don't use SFML to draw. app_window.resetGLStates(); // Create our main SFGUI window auto window = sfg::Window::Create(); window->SetTitle( "Title" ); // Create the combo box itself. m_combo_box = sfg::ComboBox::Create(); // Set the entries of the combo box. m_combo_box->AppendItem( "Bar" ); m_combo_box->PrependItem( "Foo" ); m_sel_label = sfg::Label::Create( L"Please select an item!" ); auto add_button = sfg::Button::Create( L"Add item" ); auto remove_button = sfg::Button::Create( L"Remove first item" ); auto clear_button = sfg::Button::Create( L"Clear items" ); auto hbox = sfg::Box::Create( sfg::Box::Orientation::HORIZONTAL, 5 ); hbox->Pack( m_combo_box ); hbox->Pack( add_button, false ); hbox->Pack( remove_button, false ); hbox->Pack( clear_button, false ); auto vbox = sfg::Box::Create( sfg::Box::Orientation::VERTICAL, 5 ); vbox->Pack( hbox, false ); vbox->Pack( m_sel_label, true ); // Add the combo box to the window window->Add( vbox ); // So that our combo box has a meaningful purpose (besides just looking // awesome :P) we need to tell it to connect to a callback of our choosing to // notify us when it is clicked. m_combo_box->GetSignal( sfg::ComboBox::OnSelect ).Connect( std::bind( &ComboBoxExample::OnComboSelect, this ) ); add_button->GetSignal( sfg::Widget::OnLeftClick ).Connect( std::bind( &ComboBoxExample::OnAddItemClick, this ) ); remove_button->GetSignal( sfg::Widget::OnLeftClick ).Connect( std::bind( &ComboBoxExample::OnRemoveItemClick, this ) ); clear_button->GetSignal( sfg::Widget::OnLeftClick ).Connect( std::bind( &ComboBoxExample::OnClearClick, this ) ); // If attempting to connect to a class method you need to provide // a pointer to it as the second parameter after the function address. // Start the game loop while ( app_window.isOpen() ) { // Process events sf::Event event; while ( app_window.pollEvent( event ) ) { // Handle events window->HandleEvent( event ); // Close window : exit if ( event.type == sf::Event::Closed ) { app_window.close(); } } // Update the GUI, note that you shouldn't normally // pass 0 seconds to the update method. window->Update( 0.f ); // Clear screen app_window.clear(); // Draw the GUI m_sfgui.Display( app_window ); // Update the window app_window.display(); } }