Example #1
0
GtkWidget * yui_gl_new(void) {
	GtkWidget * drawingArea;
#ifdef HAVE_LIBGTKGLEXT
	int attribs[] = {
		GDK_GL_RGBA,
		GDK_GL_RED_SIZE,   1,
		GDK_GL_GREEN_SIZE, 1,
		GDK_GL_BLUE_SIZE,  1,

		GDK_GL_DOUBLEBUFFER,

		GDK_GL_DEPTH_SIZE ,1,
        GDK_GL_STENCIL_SIZE ,8,
		GDK_GL_ATTRIB_LIST_NONE 
	};
#endif

	drawingArea = GTK_WIDGET(g_object_new(yui_gl_get_type(), NULL));
	YUI_GL(drawingArea)->is_init = 0;

#ifdef HAVE_LIBGTKGLEXT
	gtk_widget_set_gl_capability(drawingArea, gdk_gl_config_new(attribs), NULL, TRUE, GDK_GL_RGBA_TYPE);
#endif

	g_signal_connect (GTK_OBJECT(drawingArea),"configure_event", GTK_SIGNAL_FUNC(yui_gl_resize),0);

	gtk_widget_set_events(drawingArea, GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);

	g_signal_connect(GTK_OBJECT(drawingArea), "motion-notify-event", GTK_SIGNAL_FUNC(yui_gl_hide_cursor),0);
	g_signal_connect(GTK_OBJECT(drawingArea), "button-press-event", GTK_SIGNAL_FUNC(yui_gl_button_press),0);
	g_signal_connect(GTK_OBJECT(drawingArea), "button-release-event", GTK_SIGNAL_FUNC(yui_gl_button_release),0);

	return drawingArea;
}
Example #2
0
int main(int argc, char **argv)
{
	gtk_init(&argc, &argv);

	GtkWidget   *window   = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	GtkWidget   *drawing  = gtk_drawing_area_new();
	GdkGLConfig *glconfig = gdk_gl_config_new_by_mode((GdkGLConfigMode)(
			GDK_GL_MODE_RGBA   | GDK_GL_MODE_DEPTH |
			GDK_GL_MODE_DOUBLE | GDK_GL_MODE_ALPHA));
	g_signal_connect(window,  "destroy",         G_CALLBACK(gtk_main_quit), NULL);
	g_signal_connect(window,  "key-press-event", G_CALLBACK(on_key_press),  NULL);
	g_signal_connect(drawing, "expose-event",    G_CALLBACK(on_expose),     NULL);
	g_signal_connect(drawing, "configure-event", G_CALLBACK(on_configure),  NULL);
	gtk_widget_set_gl_capability(drawing, glconfig, NULL, TRUE, GDK_GL_RGBA_TYPE);
	gtk_container_add(GTK_CONTAINER(window), drawing);
	gtk_widget_show_all(window);

	/* OpenGL setup */
	GdkGLContext  *glcontext  = gtk_widget_get_gl_context(GTK_WIDGET(drawing));
	GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable(GTK_WIDGET(drawing));
	gdk_gl_drawable_gl_begin(gldrawable, glcontext);

	/* Go */
	gtk_main();
	gdk_gl_drawable_gl_end(gldrawable);
}
Example #3
0
void realizeOpenGL(struct OpenGL* ogl, long long gtkWindow_) {
	GtkWidget* window = GTK_WIDGET((void*) gtkWindow_);

	GdkGLConfig
			* config = gdk_gl_config_new_by_mode_for_screen(
					gdk_screen_get_default(), GDK_GL_MODE_RGB
							| GDK_GL_MODE_SINGLE/*| GDK_GL_MODE_DOUBLE*/);
	if (config == NULL)
		return;

	//printf("ogl=%p\n", ogl);
	ogl->config = config;

	gtk_widget_unrealize(window);
	if (!gtk_widget_set_gl_capability(window, ogl->config, NULL, FALSE,
			GDK_GL_RGBA_TYPE)) {
		fprintf(stderr, "Cannot enable GDKGL on window");
		return;
	}

	gtk_widget_realize(window);
	GdkGLDrawable* drawable = gtk_widget_get_gl_drawable(GTK_WIDGET(window));

	ogl->drawable = drawable;
	ogl->widget = GTK_WIDGET(window);
	ogl->context = gtk_widget_get_gl_context(ogl->widget);


	glEnableClientState(GL_VERTEX_ARRAY);
	glEnableClientState(GL_COLOR_ARRAY);
	glVertexPointer(2, GL_SHORT, 0, ogl->vertices);
	//gdk_gl_drawable_gl_begin(ogl->drawable, ogl->context);

}
Example #4
0
GtkWidget *
StatGraph(GraphData * pgd)
{
    float f1, f2;
    GtkWidget *pw;

    /* Drawing area for OpenGL */
    pw = gtk_drawing_area_new();
    /* Set OpenGL-capability to the widget - no list sharing */
    if ((pw == NULL) || !gtk_widget_set_gl_capability(pw, getGlConfig(), NULL, TRUE, GDK_GL_RGBA_TYPE)) {
        g_print("Can't create opengl capable widget\n");
        return NULL;
    }

    f1 = pgd->data[pgd->numGames][0][0] + pgd->data[pgd->numGames][0][1];
    f2 = pgd->data[pgd->numGames][1][0] + pgd->data[pgd->numGames][1][1];
    pgd->maxY = (f1 > f2) ? f1 : f2;
    if (pgd->maxY < .5f)
        pgd->maxY = .5f;

    gtk_widget_set_events(pw, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK);
    g_signal_connect(G_OBJECT(pw), "button_press_event", G_CALLBACK(graph_button_press_event), pgd);
    g_signal_connect(G_OBJECT(pw), "realize", G_CALLBACK(realize), pgd);
    g_signal_connect(G_OBJECT(pw), "configure_event", G_CALLBACK(configure_event), pgd);
    g_signal_connect(G_OBJECT(pw), "expose_event", G_CALLBACK(expose_event), pgd);
    g_signal_connect(G_OBJECT(pw), "destroy", G_CALLBACK(destroy_event), NULL);

    return pw;
}
int window_system_initialise(int argc, char ***argv)
{
	gtk_init(&argc, argv);
	gtk_gl_init(&argc, argv);

	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_default_size(GTK_WINDOW (window), DEFAULT_WIN_WIDTH, DEFAULT_WIN_HEIGHT);
	drawing_area = gtk_drawing_area_new();
	gtk_container_add(GTK_CONTAINER(window), drawing_area);
	g_signal_connect_swapped(window, "destroy",
	                         G_CALLBACK (gtk_main_quit), NULL);
	gtk_widget_set_events(drawing_area, GDK_EXPOSURE_MASK);

	gl_config = gdk_gl_config_new_by_mode(GDK_GL_MODE_RGB |
					      GDK_GL_MODE_DEPTH |
					      GDK_GL_MODE_DOUBLE);

	if (!gl_config) {
		printf("Messed up the config :(\n");
		exit(1);
	}

	if (!gtk_widget_set_gl_capability(drawing_area, gl_config, NULL, TRUE,
                                          GDK_GL_RGBA_TYPE)) {
		printf("Couldn't get capabilities we needed :(\n");
		exit(1);
	}

        return 0;
}
Example #6
0
native_handle _chisel_native_openglview_create( ) {
	static int glsetup = 0;
	
	if ( !glsetup ) {
		gtk_gl_init_check( NULL, NULL );
		glsetup = 1;
	}
	
	GtkWidget *widget = gtk_drawing_area_new( );
	gtk_widget_set_size_request (widget, 120, 120); 
	
	_chisel_gtk_setup_events( widget );
	//g_signal_connect( G_OBJECT(widget), "size_allocate", G_CALLBACK(_chisel_native_openglview_resize_event), NULL );
	//g_signal_connect_after( G_OBJECT(widget), "configure-event", G_CALLBACK(_chisel_native_openglview_configure_event), NULL );
	//
	
	gtk_widget_set_events( widget, GDK_EXPOSURE_MASK );

	
	GdkGLConfigMode glcmode = (GdkGLConfigMode)(GDK_GL_MODE_RGB
	                                | GDK_GL_MODE_DEPTH
	                                | GDK_GL_MODE_DOUBLE);

	GdkGLConfig *glconfig = gdk_gl_config_new_by_mode( glcmode );
	assert( glconfig != NULL );
	assert( gtk_widget_set_gl_capability( widget, glconfig, NULL, TRUE, GDK_GL_RGBA_TYPE ) );
	
	g_signal_connect( G_OBJECT(widget), "expose-event", G_CALLBACK(_chisel_native_openglview_expose_event), NULL );
	
	return widget;
}
Example #7
0
int main (int argc, char* argv[])
{
	GtkWidget* window;
	GtkWidget* drawarea;
	GdkGLConfig* glconfig;

	gtk_init (&argc, &argv);
	gdk_gl_init (&argc, &argv);

	window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
	drawarea = gtk_drawing_area_new ();
	gtk_widget_set_size_request (drawarea, 400, 300);
	gtk_container_add (GTK_CONTAINER (window), drawarea);
	g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL);
	gtk_widget_set_events (drawarea, GDK_EXPOSURE_MASK);

	glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB | GDK_GL_MODE_DEPTH | GDK_GL_MODE_DOUBLE);
	gtk_widget_set_gl_capability (drawarea, glconfig, NULL, TRUE, GDK_GL_RGBA_TYPE);

	gtk_signal_connect (GTK_OBJECT (drawarea), "expose-event", G_CALLBACK (display), NULL);
	gtk_signal_connect (GTK_OBJECT (drawarea), "configure-event", G_CALLBACK (reshape), NULL);
	g_idle_add (idle, drawarea);

	gtk_widget_show_all (window);
	gtk_main ();

	return 0;
}
OSRWindow::OSRWindow(OSRBrowserProvider* browser_provider,
                     bool transparent,
                     ClientWindowHandle parentView)
    : renderer_(transparent),
      browser_provider_(browser_provider),
      gl_enabled_(false),
      painting_popup_(false),
      render_task_pending_(false) {
  glarea_ = gtk_drawing_area_new();
  DCHECK(glarea_);

  GdkGLConfig* glconfig = gdk_gl_config_new_by_mode(
      static_cast<GdkGLConfigMode>(GDK_GL_MODE_RGB |
                                   GDK_GL_MODE_DEPTH |
                                   GDK_GL_MODE_DOUBLE));
  DCHECK(glconfig);

  gtk_widget_set_gl_capability(glarea_, glconfig, NULL, TRUE,
                               GDK_GL_RGBA_TYPE);

  gtk_widget_set_can_focus(glarea_, TRUE);

  g_signal_connect(G_OBJECT(glarea_), "size_allocate",
                   G_CALLBACK(glarea_size_allocation), this);

  gtk_widget_set_events(glarea_,
                        GDK_BUTTON_PRESS_MASK |
                        GDK_BUTTON_RELEASE_MASK |
                        GDK_KEY_PRESS_MASK |
                        GDK_KEY_RELEASE_MASK |
                        GDK_ENTER_NOTIFY_MASK |
                        GDK_LEAVE_NOTIFY_MASK |
                        GDK_POINTER_MOTION_MASK |
                        GDK_POINTER_MOTION_HINT_MASK |
                        GDK_SCROLL_MASK |
                        GDK_FOCUS_CHANGE_MASK);
  g_signal_connect(G_OBJECT(glarea_), "button_press_event",
                   G_CALLBACK(glarea_click_event), this);
  g_signal_connect(G_OBJECT(glarea_), "button_release_event",
                   G_CALLBACK(glarea_click_event), this);
  g_signal_connect(G_OBJECT(glarea_), "key_press_event",
                   G_CALLBACK(glarea_key_event), this);
  g_signal_connect(G_OBJECT(glarea_), "key_release_event",
                   G_CALLBACK(glarea_key_event), this);
  g_signal_connect(G_OBJECT(glarea_), "enter_notify_event",
                   G_CALLBACK(glarea_move_event), this);
  g_signal_connect(G_OBJECT(glarea_), "leave_notify_event",
                   G_CALLBACK(glarea_move_event), this);
  g_signal_connect(G_OBJECT(glarea_), "motion_notify_event",
                   G_CALLBACK(glarea_move_event), this);
  g_signal_connect(G_OBJECT(glarea_), "scroll_event",
                   G_CALLBACK(glarea_scroll_event), this);
  g_signal_connect(G_OBJECT(glarea_), "focus_in_event",
                   G_CALLBACK(glarea_focus_event), this);
  g_signal_connect(G_OBJECT(glarea_), "focus_out_event",
                   G_CALLBACK(glarea_focus_event), this);

  gtk_container_add(GTK_CONTAINER(parentView), glarea_);
}
int
main (int argc,
      char *argv[])
{
   unicap_handle_t handle;
   unicap_format_t format;
   
   /* Initialize */
   gtk_init (&argc, &argv);
   g_thread_init(NULL);
   gdk_threads_init ();
   gtk_gl_init (&argc, &argv);
   init_extensions ();
   init_gl_resources ();

   handle = open_device();
   set_format( handle );
   unicap_get_format( handle, &format );
   if( ( format.size.width != 640 ) ||
       ( format.size.height != 480 ) )
   {
      g_warning( "The default .cg file assumes a video format of 640x480 pixels. \nYou need to change the yuv.cg file to match your size.\n" );
   }
   
   prepare_yuv_buffer(&yuvbuffer, &format);
   unicap_register_callback( handle, UNICAP_EVENT_NEW_FRAME, (unicap_callback_t)new_frame_cb, NULL ); 
   unicap_start_capture( handle );
   

   /* Gtk window & container */
   GtkWindow *window = GTK_WINDOW (gtk_window_new (GTK_WINDOW_TOPLEVEL));
   glarea = gtk_drawing_area_new ();
   gtk_widget_set_size_request (GTK_WIDGET (glarea), WINDOW_WIDTH, WINDOW_HEIGHT);
   g_signal_connect (glarea, "expose-event", G_CALLBACK (on_expose), NULL);
   g_signal_connect (glarea, "configure-event", G_CALLBACK (on_configure), NULL);
   g_signal_connect (glarea, "map-event", G_CALLBACK (on_mapped), NULL);
   g_signal_connect (window, "delete-event", G_CALLBACK (gtk_main_quit), NULL);

   GdkGLConfig *gl_config;
   gl_config = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGBA | GDK_GL_MODE_DOUBLE);

   if (gl_config == NULL) 
      g_critical ("Failed to setup a double-buffered RGB visual");

   if (! gtk_widget_set_gl_capability (GTK_WIDGET (glarea), 
				       gl_config,
				       NULL,
				       TRUE,
				       GDK_GL_RGBA_TYPE))
      g_critical ("Failed to add gl capability");

   gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (glarea));
   gtk_widget_show_all (GTK_WIDGET (window));


   /* Main loop */
   gtk_main ();
   return 0;
}
Example #10
0
void
GtkGlExtGlue::prepDrawingArea(GtkWidget *drawing_area)
{
//    GNASH_REPORT_FUNCTION;
    _drawing_area = drawing_area;
    gtk_widget_set_gl_capability(_drawing_area, _glconfig,
                                 NULL, TRUE, GDK_GL_RGBA_TYPE);
}
Example #11
0
void GLBase::init(GdkGLConfig *Config, int PixFormat)
{
	gtk_widget_set_gl_capability(widget->GetWidget(), Config, NULL, true, PixFormat);
	gtk_widget_set_app_paintable(widget->GetWidget(), true);
	Conf = Config;
	ctx = NULL;
	drw = NULL;
	TimeoutID = 0;
}
GtkWidget* WINAPI gtk_glwidget_new( gboolean zbuffer, GtkWidget* share ){
	GtkWidget* drawing_area = gtk_drawing_area_new();
	GdkGLConfig* glconfig = ( zbuffer ) ? glconfig_new_with_depth() : glconfig_new();
	GdkGLContext* shared_context = ( share ) ? gtk_widget_get_gl_context( share ) : NULL;

	gtk_widget_set_gl_capability( drawing_area, glconfig, shared_context, TRUE, GDK_GL_RGBA_TYPE );

	return drawing_area;
}
Example #13
0
void CGLDrawingArea::MakeDrawingAreaAnOpenGLContext()
/***************************************/
{
    GtkWidget* widget = reinterpret_cast<GtkWidget*>(gobj());
    gtk_widget_set_gl_capability(widget,
                                 GLConfig(),
                                 NULL,
                                 TRUE,
                                 GDK_GL_RGBA_TYPE);
}
void draw_setup(GtkDrawingArea *draw, struct program *p)
{
	GObject *obj = G_OBJECT(draw);

	gtk_widget_set_gl_capability(GTK_WIDGET(draw), p->draw.config, NULL,
	                             TRUE, GDK_GL_RGBA_TYPE);

	g_signal_connect_after(obj, "realize", G_CALLBACK(realize), p);
	g_signal_connect(obj, "configure-event", G_CALLBACK(configure), p);
	g_signal_connect(obj, "expose-event", G_CALLBACK(expose), p);
}
Example #15
0
//view
void mShowToolBoxSlot(GtkWidget * widget, gpointer user_data)
{


    if (!gtk_widget_set_gl_capability
	(glade_xml_get_widget(xml, "glfixed"), configure_gl(),
	 gtk_widget_get_gl_context(view->drawing_area), 0, 0))
	printf("glwidget creation failed \n");



}
bool OSGGTKDrawingArea::createWidget(int width, int height) {
    _glconfig = gdk_gl_config_new_by_mode(static_cast<GdkGLConfigMode>(
        GDK_GL_MODE_RGBA |
        GDK_GL_MODE_DEPTH |
        GDK_GL_MODE_DOUBLE
    ));

    if(not _glconfig) {
        osg::notify(osg::FATAL) << "Fail!" << std::endl;

        return false;
    }

    gtk_widget_set_size_request(_widget, width, height);

    gtk_widget_set_gl_capability(
        _widget,
        _glconfig,
        0,
        true,
        GDK_GL_RGBA_TYPE
    );

    gtk_widget_add_events(
        _widget,
        GDK_BUTTON1_MOTION_MASK |
        GDK_BUTTON2_MOTION_MASK |
        GDK_BUTTON3_MOTION_MASK |
        GDK_POINTER_MOTION_MASK |
        GDK_BUTTON_PRESS_MASK |
        GDK_BUTTON_RELEASE_MASK |
        GDK_KEY_PRESS_MASK |
        GDK_KEY_RELEASE_MASK |
        GDK_VISIBILITY_NOTIFY_MASK
    );

    // We do this so that we don't have to suck up ALL the input to the
    // window, but instead just when the drawing area is focused.
    g_object_set(_widget, "can-focus", true, NULL);

    _connect("realize", G_CALLBACK(&OSGGTKDrawingArea::_srealize));
    _connect("unrealize", G_CALLBACK(&OSGGTKDrawingArea::_sunrealize));
    _connect("expose_event", G_CALLBACK(&OSGGTKDrawingArea::_sexpose_event));
    _connect("configure_event", G_CALLBACK(&OSGGTKDrawingArea::_sconfigure_event));
    _connect("motion_notify_event", G_CALLBACK(&OSGGTKDrawingArea::_smotion_notify_event));
    _connect("button_press_event", G_CALLBACK(&OSGGTKDrawingArea::_sbutton_press_event));
    _connect("button_release_event", G_CALLBACK(&OSGGTKDrawingArea::_sbutton_press_event));
    _connect("key_press_event", G_CALLBACK(&OSGGTKDrawingArea::_skey_press_event));

    _gw = setUpViewerAsEmbeddedInWindow(0, 0, width, height);

    return true;
}
Example #17
0
int
main (int argc, char **argv)
{
	RunAllTests();
	
	GtkWidget *window;
	GtkWidget *da;
	GdkGLConfig *glconfig;

	gtk_init (&argc, &argv);
	gtk_gl_init (&argc, &argv);

	window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
	gtk_window_set_default_size (GTK_WINDOW (window), 800, 600);
	da = gtk_drawing_area_new ();

	gtk_container_add (GTK_CONTAINER (window), da);
	g_signal_connect_swapped (window, "destroy",
			G_CALLBACK (gtk_main_quit), NULL);
	gtk_widget_set_events (da, GDK_EXPOSURE_MASK);

	gtk_widget_show (window);

	/* prepare GL */
	glconfig = gdk_gl_config_new_by_mode ((GdkGLConfigMode)
			(GDK_GL_MODE_RGB |
			GDK_GL_MODE_DEPTH |
			GDK_GL_MODE_DOUBLE));

	if (!glconfig)
	{
		g_assert_not_reached ();
	}

	if (!gtk_widget_set_gl_capability (da, glconfig, NULL, TRUE,
				GDK_GL_RGBA_TYPE))
	{
		g_assert_not_reached ();
	}

	g_signal_connect (da, "configure-event",
			G_CALLBACK (configure), NULL);
	g_signal_connect (da, "expose-event",
			G_CALLBACK (expose), NULL);

	gtk_widget_show_all (window);

	g_timeout_add (1000 / 30, rotate, da);
	
	t3dInit();
	
	gtk_main ();
}
Example #18
0
void Interface_iniciar() {
  GtkWidget *window;
  GdkGLConfig *glconfig;

  gtk_init(NULL, NULL);
  gtk_gl_init(NULL, NULL);


  GtkBuilder *builderPrincipal=Interface_carregarXML(INTERFACE_PRINCIPAL);
  window = GTK_WIDGET(gtk_builder_get_object (builderPrincipal, "window"));
  drawOpengl=GTK_WIDGET(gtk_builder_get_object(builderPrincipal, "drawOpengl"));
  frameProgresso=GTK_WIDGET(gtk_builder_get_object(builderPrincipal, "frameProgresso"));
  progress=GTK_PROGRESS_BAR(gtk_builder_get_object(builderPrincipal, "progressbar"));
  labelPosicaoXY=GTK_LABEL(gtk_builder_get_object(builderPrincipal, "labelPosicaoXY"));
  ajustScrollHorizGL=GTK_ADJUSTMENT(gtk_builder_get_object(builderPrincipal, "ajustScrollHorizGL"));
  ajustScrollVertGL=GTK_ADJUSTMENT(gtk_builder_get_object(builderPrincipal, "ajustScrollVertGL"));
  adjustAlpha=GTK_ADJUSTMENT(gtk_builder_get_object(builderPrincipal, "adjustAlpha"));
  tbAddEntidade=GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(builderPrincipal, "tbAddEntidade"));
  tbAddImagem=GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(builderPrincipal, "tbAddImagem"));
  tbAddTexto=GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(builderPrincipal, "tbAddTexto"));
  tbAmpliar=GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(builderPrincipal, "tbAmpliar"));
  tbReduzir=GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(builderPrincipal, "tbReduzir"));
  frameFerramentas=GTK_WIDGET(gtk_builder_get_object(builderPrincipal, "frameFerramentas"));

  /*gtk_adjustment_set_value(GTK_ADJUSTMENT(gtk_builder_get_object(builderPrincipal, "ajustScrollHorizGL")),500);
  gtk_adjustment_set_value(GTK_ADJUSTMENT(gtk_builder_get_object(builderPrincipal, "ajustScrollVertGL")),500);*/

  //Configura widget para opengl
  glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB    |
                                        GDK_GL_MODE_DEPTH  |
                                        GDK_GL_MODE_DOUBLE);

  if (!glconfig) {
      g_print ("*** Cannot find the double-buffered visual.\n");
      g_print ("*** Trying single-buffered visual.\n");

      /* Try single-buffered visual */
      glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB  | GDK_GL_MODE_DEPTH);
      if (!glconfig) {
          g_print ("*** No appropriate OpenGL-capable visual found.\n");
          g_assert_not_reached();
        }
    }

  if (!gtk_widget_set_gl_capability(drawOpengl, glconfig, NULL, TRUE, GDK_GL_RGBA_TYPE))
    g_assert_not_reached();

  gtk_builder_connect_signals(builderPrincipal, NULL);
  gtk_widget_show(window);

  g_object_unref(G_OBJECT(builderPrincipal));
}
Example #19
0
RenderArea::RenderArea(RenderAreaPtr theContext) : AbstractRenderWindow(jslib::JSApp::ShellErrorReporter),
    _myContextRefCount(0),
    _isFirstFrame(true)
{
    GdkGLConfig * myGLConfig = gdk_gl_config_new_by_mode(
                GdkGLConfigMode(GDK_GL_MODE_RGBA | GDK_GL_MODE_DEPTH | GDK_GL_MODE_DOUBLE | GDK_GL_MODE_ALPHA));
    if (myGLConfig == 0) {
        throw asl::Exception("can't init GL",PLUS_FILE_LINE);
    }

    // If another render area is supplied as constructor paramter, this render area is uses as
    // source for a shared y60-gl-context and gdk-gl-context.
    GdkGLContext * myGdkGLContext = 0;
    if (theContext) {
        myGdkGLContext = theContext->getGdkGlContext();
        if (!myGdkGLContext) {
            throw asl::Exception("RenderArea: Failed to get gdk GL context from shared render area.", PLUS_FILE_LINE);
        }
        setGLContext(theContext->getGLContext());
    } else {
        setGLContext(GLContextPtr(new GLContext()));
    }

    /* Set OpenGL-capability to the widget. */
    DB(cerr << "RenderArea::RenderArea() sharing with " << myGdkGLContext << endl);
    if (!gtk_widget_set_gl_capability (GTK_WIDGET(gobj()),
                myGLConfig,
                myGdkGLContext,
                true,
                GDK_GL_RGBA_TYPE))
    {
        throw asl::Exception("RenderArea: could not create GL context!", PLUS_FILE_LINE);
    }

    // enable mouse events
    Gdk::EventMask flags = get_events();
    flags |= Gdk::BUTTON_PRESS_MASK;
    flags |= Gdk::POINTER_MOTION_MASK;
    flags |= Gdk::BUTTON_RELEASE_MASK;
    flags |= Gdk::SCROLL_MASK;
    flags |= Gdk::ENTER_NOTIFY_MASK;
    flags |= Gdk::LEAVE_NOTIFY_MASK;
    set_events(flags);

    y60::EventDispatcher::get().addSource(&_myEventAdapter);
    y60::EventDispatcher::get().addSink(this);
    // TODO: createRenderer(theOtherRenderer);

    ShaderLibrary::setGLisReadyFlag(true);
}
Example #20
0
Render::Render (View *view, Glib::RefPtr<Gtk::TreeSelection> selection) :
  m_arcBall(new ArcBall()), m_view (view), m_selection(selection)
{
  set_events (Gdk::POINTER_MOTION_MASK |
	      Gdk::BUTTON_MOTION_MASK |
	      Gdk::BUTTON_PRESS_MASK |
	      Gdk::BUTTON_RELEASE_MASK |
	      Gdk::BUTTON1_MOTION_MASK |
	      Gdk::BUTTON2_MOTION_MASK |
	      Gdk::BUTTON3_MOTION_MASK);

  GdkGLConfig *glconfig;

  // glconfig is leaked at program exit
  glconfig = gdk_gl_config_new_by_mode
		    ((GdkGLConfigMode) (GDK_GL_MODE_RGBA |
					GDK_GL_MODE_ALPHA |
					GDK_GL_MODE_STENCIL |
					GDK_GL_MODE_DEPTH |
					GDK_GL_MODE_DOUBLE));
  if (!glconfig) // try single buffered
    glconfig = gdk_gl_config_new_by_mode
		      ((GdkGLConfigMode) (GDK_GL_MODE_RGBA |
					  GDK_GL_MODE_ALPHA |
					  GDK_GL_MODE_STENCIL |
					  GDK_GL_MODE_DEPTH));
  if (!gtk_widget_set_gl_capability (get_widget(), glconfig,
				     NULL, TRUE, GDK_GL_RGBA_TYPE))
    g_error (_("failed to init gl area\n"));

  memset (&m_transform.M, 0, sizeof (m_transform.M));

  Matrix3fT identity;
  Matrix3fSetIdentity(&identity);

  // set initial rotation 30 degrees around Y axis
  identity.s.M11 = identity.s.M22 = 0.5253; // cos -45
  identity.s.M12 = 0.851; // -sin -45
  identity.s.M21 = -0.851; // sin -45

  Matrix4fSetRotationScaleFromMatrix3f(&m_transform, &identity);
  m_transform.s.SW = 1.0;

  m_zoom = 120.0;
  for (uint i = 0; i < N_LIGHTS; i++)
    m_lights[i] = NULL;

  m_selection->signal_changed().connect (sigc::mem_fun(*this, &Render::selection_changed));
}
Example #21
0
gboolean glwidget_enable_gl( GtkWidget* widget, GtkWidget* widget2, gpointer data ){
	if ( widget2 == 0 && !gtk_widget_is_gl_capable( widget ) ) {
		GdkGLConfig* glconfig = ( g_object_get_data( G_OBJECT( widget ), "zbuffer" ) ) ? glconfig_new_with_depth() : glconfig_new();
		ASSERT_MESSAGE( glconfig != 0, "failed to create OpenGL config" );

		gtk_widget_set_gl_capability( widget, glconfig, g_shared != 0 ? gtk_widget_get_gl_context( g_shared ) : 0,  TRUE, GDK_GL_RGBA_TYPE );

		gtk_widget_realize( widget );
		if ( g_shared == 0 ) {
			g_shared = widget;
		}

		// free glconfig?
	}
	return FALSE;
}
Example #22
0
WaveformView*
construct ()
{
	WaveformView* self = (WaveformView*) g_object_new (TYPE_WAVEFORM_VIEW, NULL);
	gtk_widget_add_events ((GtkWidget*) self, (gint) ((GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK) | GDK_POINTER_MOTION_MASK));
	gtk_widget_set_size_request ((GtkWidget*) self, 200, 100);
	//GdkGLConfig* glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB | GDK_GL_MODE_DOUBLE);
	if(!gtk_widget_set_gl_capability((GtkWidget*)self, glconfig, gl_context, DIRECT, GDK_GL_RGBA_TYPE)){
		gwarn("failed to set gl capability");
	}

	WaveformViewPrivate* priv = self->priv;
	priv->gl_init_done = false;

	return self;
}
Example #23
0
static int lglext_widget_set_gl_capability(lua_State* L)
{
	luaL_checktype(L, 1, LUA_TUSERDATA);
	luaL_checktype(L, 2, LUA_TUSERDATA);
	luaL_checktype(L, 3, LUA_TBOOLEAN);
	luaL_checktype(L, 4, LUA_TNUMBER);

	Object* obj1 = lua_touserdata(L, 1);
	Object* obj2 = lua_touserdata(L, 2);

	gboolean res = gtk_widget_set_gl_capability(GTK_WIDGET(obj1->pointer),
		GDK_GL_CONFIG(obj2->pointer), NULL, lua_toboolean(L, 3),
		lua_tointeger(L, 4));

	lua_pushboolean(L, res);

	return 1;
}
Example #24
0
int
main (int argc, char *argv[])
{
	set_log_handlers();

	wf_debug = 1;

	gtk_init(&argc, &argv);
	GdkGLConfig* glconfig;
	if(!(glconfig = gdk_gl_config_new_by_mode(GDK_GL_MODE_RGBA | GDK_GL_MODE_DEPTH | GDK_GL_MODE_DOUBLE))){
		gerr ("Cannot initialise gtkglext."); return EXIT_FAILURE;
	}

	GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

	canvas = gtk_drawing_area_new();
	gtk_widget_set_can_focus     (canvas, true);
	gtk_widget_set_size_request  (canvas, GL_WIDTH + 2 * HBORDER, 128);
	gtk_widget_set_gl_capability (canvas, glconfig, NULL, 1, GDK_GL_RGBA_TYPE);
	gtk_widget_add_events        (canvas, GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
	gtk_container_add((GtkContainer*)window, (GtkWidget*)canvas);

	agl = agl_get_instance();

	scene = (AGlRootActor*)agl_actor__new_root(canvas);

	wfc = wf_canvas_new((AGlRootActor*)scene);

	char* filename = find_wav(WAV);
	w1 = waveform_load_new(filename);
	g_free(filename);

	g_signal_connect((gpointer)canvas, "realize",       G_CALLBACK(on_canvas_realise), NULL);
	g_signal_connect((gpointer)canvas, "size-allocate", G_CALLBACK(on_allocate), NULL);
	g_signal_connect((gpointer)canvas, "expose-event",  G_CALLBACK(agl_actor__on_expose), scene);

	gtk_widget_show_all(window);

	add_key_handlers((GtkWindow*)window, NULL, (Key*)&keys);

	gboolean window_on_delete(GtkWidget* widget, GdkEvent* event, gpointer user_data){
		gtk_main_quit();
		return false;
	}
Example #25
0
static void grits_tester_init(GritsTester *tester)
{
	g_debug("GritsTester: init");
	tester->objects = NULL;

	/* Set OpenGL before "realize" */
	GdkGLConfig *glconfig = gdk_gl_config_new_by_mode(
			GDK_GL_MODE_RGBA   | GDK_GL_MODE_DEPTH |
			GDK_GL_MODE_DOUBLE | GDK_GL_MODE_ALPHA);
	if (!glconfig)
		g_error("Failed to create glconfig");
	if (!gtk_widget_set_gl_capability(GTK_WIDGET(tester),
				glconfig, NULL, TRUE, GDK_GL_RGBA_TYPE))
		g_error("GL lacks required capabilities");
	g_object_unref(glconfig);

	/* Finish OpenGL init after it's realized */
	g_signal_connect(tester, "realize", G_CALLBACK(on_realize), NULL);
}
Example #26
0
static void cb_init_ext(GtkWidget *widget)
{
	GdkGLConfig *config; // la config qui va aller avec
	
	static const gint attrList[] = { // les paramètres de la config
		GDK_GL_DOUBLEBUFFER,
		GDK_GL_RGBA,
		GDK_GL_RED_SIZE, 1,
		GDK_GL_GREEN_SIZE, 1,
		GDK_GL_BLUE_SIZE, 1,
		GDK_GL_ALPHA_SIZE, 1,
		GDK_GL_DEPTH_SIZE, 1,
		GDK_GL_ATTRIB_LIST_NONE };
	
	config = gdk_gl_config_new(attrList);
	
	/* ajout du support Opengl */
	gtk_widget_set_gl_capability(widget, config, NULL, TRUE, GDK_GL_RGBA_TYPE);
}
Example #27
0
int
darxen_splash_run()
{
	GMainLoop *loop;
	int i;

	if (mfrmSplash)
		g_error("Splash screen has been shown already");

	for (i = 0; i < PROGRESS_COUNT; i++)
		intProgressTimeTotal += objProgressItems[i].intTime;

	glSettings = (SettingsGL*)malloc(sizeof(SettingsGL));

	mfrmSplash = gtk_window_new(GTK_WINDOW_POPUP);
	gtk_window_set_decorated(GTK_WINDOW(mfrmSplash), FALSE);
	gtk_window_set_title(GTK_WINDOW(mfrmSplash), "loading DARXEN...");
	gtk_window_set_position(GTK_WINDOW(mfrmSplash), GTK_WIN_POS_CENTER);

	darxen_splash_gl_init();
	darea = gtk_drawing_area_new();
	gtk_widget_set_gl_capability(darea, glSettings->glConfig, NULL, TRUE, GDK_GL_RGBA_TYPE);
	g_signal_connect(darea, "realize", (GCallback)darxen_splash_darea_realize, NULL);
	g_signal_connect(darea, "configure_event", (GCallback)darxen_splash_darea_configure, NULL);
	g_signal_connect(darea, "expose_event", (GCallback)darxen_splash_darea_expose, NULL);
	gtk_widget_set_size_request(darea, 300, 200);

	gtk_container_add(GTK_CONTAINER(mfrmSplash), darea);

	gtk_widget_show_all(mfrmSplash);

	loop = g_main_loop_new(NULL, FALSE);

	g_timeout_add_full(G_PRIORITY_LOW, 100, darxen_splash_load, loop, NULL);

	g_main_loop_run(loop);
	g_main_loop_unref(loop);

	gtk_widget_hide(mfrmSplash);

	return 0;
}
Example #28
0
	/// Returns a "global" (to the document) gdkgl context that can be used to share display lists
  GdkGLContext* gdkgl_share_list()
  {
    if(!m_gdkgl_share_list)
    {
      GdkGLConfig* const config = gdk_gl_config_new_by_mode(
        static_cast<GdkGLConfigMode>(GDK_GL_MODE_RGBA | GDK_GL_MODE_DOUBLE | GDK_GL_MODE_DEPTH));
      return_val_if_fail(config, 0);

      Gtk::Window* const window = new Gtk::Window();
      gtk_widget_set_gl_capability(GTK_WIDGET(window->gobj()), config, 0, true, GDK_GL_RGBA_TYPE);
      window->show();
      window->hide();

      GdkGLContext* const context = gtk_widget_get_gl_context(GTK_WIDGET(window->gobj()));
      return_val_if_fail(context, 0);

      m_gdkgl_share_list = context;
    }

    return m_gdkgl_share_list;
  }
static GtkWidget *
CreateGLPreviewWidget(Material * pMat)
{                               /* Rename this (and the one above to CreateGLBoardWidget) */
    GtkWidget *p3dWidget = gtk_drawing_area_new();

    /* Set OpenGL-capability to the widget - no list sharing */
    if (!gtk_widget_set_gl_capability(p3dWidget, getGlConfig(), NULL, TRUE, GDK_GL_RGBA_TYPE)) {
        outputerrf("Can't create opengl capable widget\n");
        return NULL;
    }

    if (p3dWidget == NULL) {
        outputerrf("Can't create opengl drawing widget\n");
        return NULL;
    }

    g_signal_connect(G_OBJECT(p3dWidget), "realize", G_CALLBACK(realize_preview3d), NULL);
    g_signal_connect(G_OBJECT(p3dWidget), "expose_event", G_CALLBACK(expose_event_preview3d), pMat);

    return p3dWidget;
}
Example #30
0
gboolean GLWidget::onHierarchyChanged(GtkWidget* widget,
		GtkWidget* previous_toplevel, GLWidget* self) {
	if (previous_toplevel == NULL && !gtk_widget_is_gl_capable(widget)) {
		// Create a new GL config structure
		GdkGLConfig* glconfig = (self->_zBuffer) ? createGLConfigWithDepth()
				: createGLConfig();
		ASSERT_MESSAGE(glconfig != NULL, "failed to create OpenGL config");

		gtk_widget_set_gl_capability(widget, glconfig,
				g_shared != NULL ? gtk_widget_get_gl_context(g_shared) : NULL,
				TRUE, GDK_GL_RGBA_TYPE);

		gtk_widget_realize(widget);

		// Shared not set yet?
		if (g_shared == 0) {
			g_shared = widget;
		}
	}

	return FALSE;
}