/** update everything about mapping, leaving the viewport alone */ void Canvas::update_mapping ( void ) { _update_row_mapping(); m.mapping_drawn = false; resize(); int old_margin = m.margin_left; m.margin_left = 0; m.draw = false; m.grid->draw_row_names( this ); if ( m.margin_left != old_margin ) { signal_resize(); signal_draw(); } else signal_draw(); }
/** * Draw the current frame */ static void ps_draw() { GFraMe_event_draw_begin(); #ifdef DEBUG _drwCalls++; #endif map_draw(m); rg_drawBullets(); rg_drawObjects(); rg_drawMobs(); if (gv_nIsZero(SWITCH_MAP)) transition_draw(); ui_draw(); player_draw(p2); player_draw(p1); if (gv_isZero(SWITCH_MAP)) signal_draw(); #ifdef QT_DEBUG_DRAW if (GFraMe_keys.f1 || (GFraMe_controller_max > 0 && GFraMe_controllers[0].l2)) qt_drawRootDebug(); #endif if (_ps_pause) { ps_drawPause(); } if (_ps_isSpeedrun) timer_draw(); if (_ps_text) { textWnd_draw(); } GFraMe_event_draw_end(); }
Graph_disp::Graph_disp(const sf::VideoMode & mode, const int size_request, const sf::ContextSettings & context_settings): SFMLWidget(mode, size_request, context_settings), draw_cursor_flag(true), draw_axes_flag(true), use_orbit_cam(true), cam_light(glm::vec3(1.0f), 0.2f, glm::vec3(0.0f), 1.0f, 0.5f, 0.0f), dir_light(glm::vec3(0.5f), 0.2f, glm::vec3(-1.0f)), bkg_color(0.25f, 0.25f, 0.25f), ambient_color(0.4f, 0.4f, 0.4f), _cam(glm::vec3(0.0f, -10.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f), glm::vec3(0.0f, 0.0f, 1.0f)), _orbit_cam({10.0f, 0.0f, (float)M_PI / 2.0f}), _scale(1.0f), _perspective(1.0f), _active_graph(nullptr) { // All OpenGL initialization has to wait until the drawing context actually exists // we do this in the initialize method // connect it to the draw signal, to be run only on the first drawing request _draw_connection = signal_draw().connect(sigc::mem_fun(*this, &Graph_disp::initiaize)); // connect event signals signal_size_allocate().connect(sigc::mem_fun(*this, &Graph_disp::resize)); signal_key_press_event().connect(sigc::mem_fun(*this, &Graph_disp::key_press)); // input is checked every 10ms Glib::signal_timeout().connect(sigc::mem_fun(*this, &Graph_disp::input), 10); set_can_focus(); set_can_default(); }
/** change grid to /g/, returns TRUE if new grid size differs from old */ void Canvas::grid ( Grid *g ) { m.grid = g; if ( ! g ) return; m.vp = &g->viewport; char *s = m.vp->dump(); DMESSAGE( "viewport: %s", s ); free( s ); m.ruler_drawn = false; resize_grid(); update_mapping(); m.shape = m.grid->draw_shape(); /* connect signals */ /* FIXME: what happens when we do this twice? */ g->signal_events_change.connect( mem_fun( this, &Canvas::handle_event_change ) ); g->signal_settings_change.connect( signal_settings_change.make_slot() ); signal_draw(); signal_settings_change(); }
void Canvas::unset ( int x, int y ) { if ( y - m.origin_y < m.margin_top ) /* looks like a click on the ruler */ { if ( x - m.margin_left - m.origin_x >= 0 ) { m.p2 = m.vp->x + ((x - m.margin_left - m.origin_x) / m.div_w); m.ruler_drawn = false; m.p3 = m.p4 = 0; } _lr(); signal_draw(); return; } if ( ! grid_pos( &x, &y ) ) return; m.grid->del( x, y ); }
/** draw only the playhead--without reexamining the grid */ int Canvas::draw_playhead ( void ) { int x = m.grid->ts_to_x( m.grid->index() ); if ( m.playhead == x ) return 0; m.playhead = x; if ( m.playhead < m.vp->x || m.playhead >= m.vp->x + m.vp->w ) { if ( config.follow_playhead ) { m.vp->x = m.playhead / m.vp->w * m.vp->w; m.ruler_drawn = false; signal_draw(); return 0; } } copy(); for ( uint x = m.vp->w; x-- ; ) for ( uint y = m.vp->h; y-- ; ) m.current[ x ][ y ].flags &= ~ (F_PLAYHEAD | F_P1 | F_P2 ); flip(); return 1; }
void Canvas::handle_event_change ( void ) { /* mark the song as dirty and pass the signal on */ song.set_dirty(); signal_draw(); }
void Canvas::pan ( int dir, int n ) { switch ( dir ) { case LEFT: case RIGHT: case TO_PLAYHEAD: case TO_NEXT_NOTE: case TO_PREV_NOTE: /* handle horizontal movement specially */ n *= m.grid->division(); m.ruler_drawn = false; break; default: n *= 5; m.mapping_drawn = false; break; } switch ( dir ) { case LEFT: m.vp->x = max( m.vp->x - n, 0 ); break; case RIGHT: m.vp->x += n; break; case TO_PLAYHEAD: m.vp->x = m.playhead - (m.playhead % m.grid->division()); break; case UP: m.vp->y = max( m.vp->y - n, 0 ); break; case DOWN: m.vp->y = min( m.vp->y + n, m.maxh - m.vp->h ); break; case TO_NEXT_NOTE: { int x = m.grid->next_note_x( m.vp->x ); m.vp->x = x - (x % m.grid->division() ); break; } case TO_PREV_NOTE: { int x = m.grid->prev_note_x( m.vp->x ); m.vp->x = x - (x % m.grid->division() ); break; } } signal_draw(); }
void Canvas::end_cursor ( int x, int y ) { if ( ! grid_pos( &x, &y ) ) return; m.ruler_drawn = false; m.p2 = x; m.p4 = ntr( y ); _lr(); signal_draw(); }
ImageWidget::ImageWidget() : _isInitialized(false), _initializedWidth(0), _initializedHeight(0), _showOriginalMask(true), _showAlternativeMask(true), _colorMap(BWMap), _image(), _highlighting(false), _startHorizontal(0.0), _endHorizontal(1.0), _startVertical(0.0), _endVertical(1.0), _segmentedImage(), _horiScale(0), _vertScale(0), _colorScale(0), _plotTitle(0), _scaleOption(NormalScale), _showXYAxes(true), _showColorScale(true), _showXAxisDescription(true), _showYAxisDescription(true), _showZAxisDescription(true), _showTitle(true), _max(1.0), _min(0.0), _range(Winsorized), _cairoFilter(Cairo::FILTER_BEST), _manualTitle(false), _manualXAxisDescription(false), _manualYAxisDescription(false), _manualZAxisDescription(false), _mouseIsIn(false) { _highlightConfig = new ThresholdConfig(); _highlightConfig->InitializeLengthsSingleSample(); add_events(Gdk::POINTER_MOTION_MASK | Gdk::BUTTON_RELEASE_MASK | Gdk::BUTTON_PRESS_MASK | Gdk::LEAVE_NOTIFY_MASK); signal_motion_notify_event().connect(sigc::mem_fun(*this, &ImageWidget::onMotion)); signal_leave_notify_event().connect(sigc::mem_fun(*this, &ImageWidget::onLeave)); signal_button_release_event().connect(sigc::mem_fun(*this, &ImageWidget::onButtonReleased)); signal_draw().connect(sigc::mem_fun(*this, &ImageWidget::onDraw) ); }
void MyArea::set_pixbuf(Gdk::Pixbuf* data) { priv->pixbuf = Glib::RefPtr<Gdk::Pixbuf>(data); signal_draw().connect( sigc::mem_fun( *priv, &MyArea_private::on_draw) ); }
// called when OpenGL context is ready and GTK widget is ready bool Graph_disp::initiaize(const Cairo::RefPtr<Cairo::Context> & unused) { // clear the screen glClearColor(bkg_color.r, bkg_color.g, bkg_color.b, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); display(); // init glew if(glewInit() != GLEW_OK) { Gtk::MessageDialog error_dialog("Error loading Glew", false, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, true); error_dialog.set_transient_for(*dynamic_cast<Gtk::Window *>(get_toplevel())); error_dialog.set_title("Fatal Error"); error_dialog.set_secondary_text("Aborting..."); error_dialog.run(); std::cerr<<"Error loading glew. Aborting"<<std::endl; dynamic_cast<Gtk::Window *>(get_toplevel())->hide(); return_code = EXIT_FAILURE; return true; } // check for required OpenGL version if(!GLEW_VERSION_3_3) { Gtk::MessageDialog error_dialog("OpenGL version too low", false, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, true); error_dialog.set_transient_for(*dynamic_cast<Gtk::Window *>(get_toplevel())); error_dialog.set_title("Fatal Error"); error_dialog.set_secondary_text("Version 3.3 required\nInstalled version is: " + std::string((const char *)glGetString(GL_VERSION)) + "\nAborting..."); error_dialog.run(); std::cerr<<"OpenGL version too low. Version 3.3 required"<<std::endl; std::cerr<<"Installed version is: "<<glGetString(GL_VERSION)<<std::endl; dynamic_cast<Gtk::Window *>(get_toplevel())->hide(); return_code = EXIT_FAILURE; return true; } std::cerr<<"OpenGL version is: "<<glGetString(GL_VERSION)<<std::endl; // init GL state vars glEnable(GL_DEPTH_TEST); glDepthRangef(0.0f, 1.0f); glLineWidth(5.0f); glEnable(GL_POLYGON_SMOOTH); glHint(GL_POLYGON_SMOOTH_HINT, GL_DONT_CARE); glEnable(GL_LINE_SMOOTH); glHint(GL_LINE_SMOOTH_HINT, GL_DONT_CARE); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBlendColor(1.0f, 1.0f, 1.0f, 0.1f); glEnable(GL_BLEND); // build shader programs GLuint graph_vert = compile_shader(check_in_pwd("shaders/graph.vert"), GL_VERTEX_SHADER); GLuint line_vert = compile_shader(check_in_pwd("shaders/line.vert"), GL_VERTEX_SHADER); GLuint common_frag = compile_shader(check_in_pwd("shaders/common.frag"), GL_FRAGMENT_SHADER); GLuint tex_frag = compile_shader(check_in_pwd("shaders/tex.frag"), GL_FRAGMENT_SHADER); GLuint color_frag = compile_shader(check_in_pwd("shaders/color.frag"), GL_FRAGMENT_SHADER); GLuint flat_color_frag = compile_shader(check_in_pwd("shaders/flat_color.frag"), GL_FRAGMENT_SHADER); if(graph_vert == 0 || line_vert == 0 || tex_frag == 0 || color_frag == 0 || flat_color_frag == 0) { // error messages are displayed by the compile_shader function Gtk::MessageDialog error_dialog("Error compiling shaders", false, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, true); error_dialog.set_transient_for(*dynamic_cast<Gtk::Window *>(get_toplevel())); error_dialog.set_title("Fatal Error"); error_dialog.set_secondary_text("See console output for details.\nAborting..."); error_dialog.run(); dynamic_cast<Gtk::Window *>(get_toplevel())->hide(); return_code = EXIT_FAILURE; return true; } // link shaders _prog_tex.prog = link_shader_prog(std::vector<GLuint> {graph_vert, tex_frag, common_frag}); _prog_color.prog = link_shader_prog(std::vector<GLuint> {graph_vert, color_frag, common_frag}); _prog_line.prog = link_shader_prog(std::vector<GLuint> {line_vert, flat_color_frag}); if(_prog_tex.prog == 0 || _prog_color.prog == 0 || _prog_line.prog == 0) { // error messages are displayed by the link_shader_prog function Gtk::MessageDialog error_dialog("Error linking shaders", false, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, true); error_dialog.set_transient_for(*dynamic_cast<Gtk::Window *>(get_toplevel())); error_dialog.set_title("Fatal Error"); error_dialog.set_secondary_text("See console output for details.\nAborting..."); error_dialog.run(); dynamic_cast<Gtk::Window *>(get_toplevel())->hide(); return_code = EXIT_FAILURE; return true; } check_error("build shaders"); // free shader objects glDeleteShader(graph_vert); glDeleteShader(line_vert); glDeleteShader(common_frag); glDeleteShader(tex_frag); glDeleteShader(color_frag); glDeleteShader(flat_color_frag); // get uniform locations for each shader bool uniform_success = true; uniform_success &= _prog_tex.add_uniform("view_model_perspective"); uniform_success &= _prog_tex.add_uniform("view_model"); uniform_success &= _prog_tex.add_uniform("normal_transform"); uniform_success &= _prog_tex.add_uniform("material.shininess"); uniform_success &= _prog_tex.add_uniform("material.specular"); uniform_success &= _prog_tex.add_uniform("ambient_color"); uniform_success &= _prog_tex.add_uniform("cam_light.base.color"); uniform_success &= _prog_tex.add_uniform("cam_light.base.strength"); uniform_success &= _prog_tex.add_uniform("cam_light.pos_eye"); uniform_success &= _prog_tex.add_uniform("cam_light.const_atten"); uniform_success &= _prog_tex.add_uniform("cam_light.linear_atten"); uniform_success &= _prog_tex.add_uniform("cam_light.quad_atten"); uniform_success &= _prog_tex.add_uniform("dir_light.base.color"); uniform_success &= _prog_tex.add_uniform("dir_light.base.strength"); uniform_success &= _prog_tex.add_uniform("dir_light.dir"); uniform_success &= _prog_tex.add_uniform("dir_light.half_vec"); uniform_success &= _prog_tex.add_uniform("light_forward"); check_error("_prog_tex GetUniformLocation"); if(!uniform_success) { std::string missing_uniforms; for(auto const & uniform: _prog_tex.uniforms) { if(uniform.second == -1) { missing_uniforms += uniform.first + "\n"; } } std::cerr<<"Error finding texture shader uniforms:\n"<<missing_uniforms<<std::endl; Gtk::MessageDialog error_dialog("Error finding texture shader uniforms", false, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, true); error_dialog.set_transient_for(*dynamic_cast<Gtk::Window *>(get_toplevel())); error_dialog.set_title("Fatal Error"); error_dialog.set_secondary_text(missing_uniforms + "Aborting..."); error_dialog.run(); dynamic_cast<Gtk::Window *>(get_toplevel())->hide(); return_code = EXIT_FAILURE; return true; } uniform_success = true; uniform_success &= _prog_color.add_uniform("view_model_perspective"); uniform_success &= _prog_color.add_uniform("view_model"); uniform_success &= _prog_color.add_uniform("normal_transform"); uniform_success &= _prog_color.add_uniform("material.shininess"); uniform_success &= _prog_color.add_uniform("material.specular"); uniform_success &= _prog_color.add_uniform("color"); uniform_success &= _prog_color.add_uniform("ambient_color"); uniform_success &= _prog_color.add_uniform("cam_light.base.color"); uniform_success &= _prog_color.add_uniform("cam_light.base.strength"); uniform_success &= _prog_color.add_uniform("cam_light.pos_eye"); uniform_success &= _prog_color.add_uniform("cam_light.const_atten"); uniform_success &= _prog_color.add_uniform("cam_light.linear_atten"); uniform_success &= _prog_color.add_uniform("cam_light.quad_atten"); uniform_success &= _prog_color.add_uniform("dir_light.base.color"); uniform_success &= _prog_color.add_uniform("dir_light.base.strength"); uniform_success &= _prog_color.add_uniform("dir_light.dir"); uniform_success &= _prog_color.add_uniform("dir_light.half_vec"); uniform_success &= _prog_color.add_uniform("light_forward"); check_error("_prog_color GetUniformLocation"); if(!uniform_success) { std::string missing_uniforms; for(auto const & uniform: _prog_color.uniforms) { if(uniform.second == -1) { missing_uniforms += uniform.first + "\n"; } } std::cerr<<"Error finding color shader uniforms:\n"<<missing_uniforms<<std::endl; Gtk::MessageDialog error_dialog("Error finding color shader uniforms", false, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, true); error_dialog.set_transient_for(*dynamic_cast<Gtk::Window *>(get_toplevel())); error_dialog.set_title("Fatal Error"); error_dialog.set_secondary_text(missing_uniforms + "Aborting..."); error_dialog.run(); dynamic_cast<Gtk::Window *>(get_toplevel())->hide(); return_code = EXIT_FAILURE; return true; } uniform_success = true; uniform_success &= _prog_line.add_uniform("perspective"); uniform_success &= _prog_line.add_uniform("view_model"); uniform_success &= _prog_line.add_uniform("color"); check_error("_prog_line GetUniformLocation"); if(!uniform_success) { std::string missing_uniforms; for(auto const & uniform: _prog_line.uniforms) { if(uniform.second == -1) { missing_uniforms += uniform.first + "\n"; } } std::cerr<<"Error finding line shader uniforms:\n"<<missing_uniforms<<std::endl; Gtk::MessageDialog error_dialog("Error finding line shader uniforms", false, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, true); error_dialog.set_transient_for(*dynamic_cast<Gtk::Window *>(get_toplevel())); error_dialog.set_title("Fatal Error"); error_dialog.set_secondary_text(missing_uniforms + "Aborting..."); error_dialog.run(); dynamic_cast<Gtk::Window *>(get_toplevel())->hide(); return_code = EXIT_FAILURE; return true; } // set up un-changing lighting values (in eye space) glm::vec3 cam_light_pos_eye(0.0f); glm::vec3 light_forward(0.0f, 0.0f, 1.0f); glUseProgram(_prog_tex.prog); glUniform3fv(_prog_tex.uniforms["cam_light.pos_eye"], 1, &cam_light_pos_eye[0]); glUniform3fv(_prog_tex.uniforms["light_forward"], 1, &light_forward[0]); check_error("_prog_tex uniforms static"); glUseProgram(_prog_color.prog); glUniform3fv(_prog_color.uniforms["cam_light.pos_eye"], 1, &cam_light_pos_eye[0]); glUniform3fv(_prog_color.uniforms["light_forward"], 1, &light_forward[0]); check_error("_prog_color uniforms static"); // create static geometry objects - cursor, axes try { _cursor.build(check_in_pwd("img/cursor.png")); } catch(Glib::Exception &e) { std::cerr<<"Error reading cursor image file:"<<std::endl<<e.what()<<std::endl; Gtk::MessageDialog error_dialog("Error reading cursor image_file", false, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, true); error_dialog.set_transient_for(*dynamic_cast<Gtk::Window *>(get_toplevel())); error_dialog.set_title("Fatal Error"); error_dialog.set_secondary_text(e.what() + std::string("\nAborting...")); error_dialog.run(); dynamic_cast<Gtk::Window *>(get_toplevel())->hide(); return_code = EXIT_FAILURE; return true; } _axes.build(); _draw_connection.disconnect(); _draw_connection = signal_draw().connect(sigc::mem_fun(*this, &Graph_disp::draw)); // explicitly setup the window size (since resize is automatically called before initialization Gtk::Allocation allocation(0, 0, get_allocated_width(), get_allocated_height()); resize(allocation); _signal_initialized.emit(); return draw(unused); }
TransparentSlider::TransparentSlider() : _redInit(0.5), _greenInit(1), _blueInit(0.5), _alphaInit(0.5), _buttonLabel("Close"), _box(Gtk::ORIENTATION_VERTICAL), _inner_box(Gtk::ORIENTATION_HORIZONTAL), _alignment(Gtk::ALIGN_END, Gtk::ALIGN_END, 0.0, 0.0), _button(_buttonLabel), _adjustmentRed(Gtk::Adjustment::create(_redInit, 0, 1.0, 0.1, 0.1, 0)), _adjustmentGreen(Gtk::Adjustment::create(_greenInit, 0, 1.0, 0.1, 0.1, 0)), _adjustmentBlue(Gtk::Adjustment::create(_blueInit, 0, 1.0, 0.1, 0.1, 0)), _adjustmentAlpha(Gtk::Adjustment::create(_alphaInit, 0, 1.0, 0.1, 0.1, 0)), _scaleRed(_adjustmentRed, Gtk::ORIENTATION_VERTICAL), _scaleGreen(_adjustmentGreen, Gtk::ORIENTATION_VERTICAL), _scaleBlue(_adjustmentBlue, Gtk::ORIENTATION_VERTICAL), _scaleAlpha(_adjustmentAlpha, Gtk::ORIENTATION_VERTICAL) { // Set up the top-level window. set_border_width(10); set_title("Color Slider Test"); set_default_size(400,400); set_decorated(false); add_events(Gdk::BUTTON_PRESS_MASK); set_position(Gtk::WIN_POS_CENTER); set_app_paintable(true); // Signal handlers signal_draw().connect(sigc::mem_fun(*this, &TransparentSlider::on_draw)); signal_screen_changed().connect(sigc::mem_fun(*this, &TransparentSlider::on_screen_changed)); signal_button_press_event().connect(sigc::mem_fun(*this, &TransparentSlider::on_window_clicked)); _button.signal_clicked().connect(sigc::mem_fun(*this, &TransparentSlider::on_button_clicked)); // Widgets // Add the box and pack it. add(_box); _box.pack_start(_inner_box); _box.pack_start(_alignment); // Pack the inner box _inner_box.set_homogeneous(); _inner_box.pack_start(_scaleRed); _inner_box.pack_start(_scaleGreen); _inner_box.pack_start(_scaleBlue); _inner_box.pack_start(_scaleAlpha); // Set up the scales: _scaleRed.set_digits(3); _scaleRed.set_inverted(); _scaleGreen.set_digits(3); _scaleGreen.set_inverted(); _scaleBlue.set_digits(3); _scaleBlue.set_inverted(); _scaleAlpha.set_digits(3); _scaleAlpha.set_inverted(); // Set up the close button _alignment.add(_button); _button.set_size_request(100, 10); // Initialize the process of drawing the colored part. on_screen_changed(get_screen()); // Show the window and all its children. show_all_children(); }