int main (int argc, char *argv[])
{

  GtkWidget *window;

  gtk_init(&argc, &argv);
  
  window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 
  g_signal_connect(window, "expose-event",
      G_CALLBACK(on_expose_event), NULL);
  g_signal_connect(window, "destroy",
      G_CALLBACK(on_destroy), NULL);
  g_signal_connect(window, "configure-event",
	  G_CALLBACK(on_configure_event), NULL);


  gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  gtk_window_set_title(GTK_WINDOW(window), "cairo_gl");
  gtk_window_set_default_size(GTK_WINDOW(window), 400, 300); 
  gtk_widget_set_app_paintable(window, TRUE);
  gtk_widget_set_double_buffered(window, FALSE);
  gtk_widget_show_all(window);

  pixmap = gdk_pixmap_new(window->window,400,300,-1);
  
  //window_surface=create_source_surface_for_widget(window);

  gtk_main();

  return 0;
}

/* Object initialization function for the image view */
static void
image_view_instance_init (ImageView *view)
{
	ImageViewPrivate *priv;

	priv = g_new0 (ImageViewPrivate, 1);
	view->priv = priv;

	GTK_WIDGET_UNSET_FLAGS (view, GTK_NO_WINDOW);
	GTK_WIDGET_SET_FLAGS (view, GTK_CAN_FOCUS);

	priv->pixbuf = NULL;
	priv->zoomx = priv->zoomy = 1.0;
	priv->hadj = NULL;
	priv->vadj = NULL;
	priv->uta = NULL;

	/* Defaults for rendering */
	priv->interp_type = GDK_INTERP_BILINEAR;
	priv->check_type = CHECK_TYPE_MIDTONE;
	priv->check_size = CHECK_SIZE_LARGE;
	priv->dither = GDK_RGB_DITHER_MAX;

	/* We don't want to be double-buffered as we are SuperSmart(tm) */
	gtk_widget_set_double_buffered (GTK_WIDGET (view), FALSE);
}

void Viewport::create(Window &parent, unsigned x, unsigned y, unsigned width, unsigned height) {
  object->widget = gtk_drawing_area_new();
  gtk_widget_set_double_buffered(object->widget, false);
  gtk_widget_set_size_request(object->widget, width, height);
  gtk_fixed_put(GTK_FIXED(parent.object->formContainer), object->widget, x, y);
  gtk_widget_show(object->widget);
}

void gui_init(dt_lib_module_t *self)
{
  /* initialize ui widgets */
  dt_lib_ratings_t *d = (dt_lib_ratings_t *)g_malloc0(sizeof(dt_lib_ratings_t));
  self->data = (void *)d;

  /* create a centered drawing area within alignment */
  self->widget = gtk_alignment_new(0.5, 0.5, 0, 0);

  GtkWidget *da = gtk_drawing_area_new();
  gtk_widget_set_events(da, GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK
                            | GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK
                            | GDK_STRUCTURE_MASK);

  /* connect callbacks */
  gtk_widget_set_double_buffered(da, FALSE);
  gtk_widget_set_app_paintable(da, TRUE);
  g_signal_connect(G_OBJECT(da), "expose-event", G_CALLBACK(_lib_ratings_expose_callback), self);
  g_signal_connect(G_OBJECT(da), "button-press-event", G_CALLBACK(_lib_ratings_button_press_callback), self);
  g_signal_connect(G_OBJECT(da), "button-release-event", G_CALLBACK(_lib_ratings_button_release_callback),
                   self);
  g_signal_connect(G_OBJECT(da), "motion-notify-event", G_CALLBACK(_lib_ratings_motion_notify_callback), self);
  g_signal_connect(G_OBJECT(da), "leave-notify-event", G_CALLBACK(_lib_ratings_leave_notify_callback), self);

  /* set size of navigation draw area */
  gtk_widget_set_size_request(da, (STAR_SIZE * 6) + (STAR_SPACING * 5), STAR_SIZE);

  gtk_container_add(GTK_CONTAINER(self->widget), da);
}

/** 
* @brief Init display
* 
* @param widget   widget to assiociate with display
* @param display  instance of gui_display to initialize
* 
* @retval WG_SUCCESS
* @retval WG_FAILURE
*/
wg_status
gui_display_init(GtkWidget *widget, Gui_display *display)
{
    CHECK_FOR_NULL_PARAM(widget);
    CHECK_FOR_NULL_PARAM(display);

    memset(display, '\0', sizeof (Gui_display));

    display->widget = widget;

    list_init(&display->lines);

    display->widget_width = gtk_widget_get_allocated_width(display->widget);
    display->widget_height = gtk_widget_get_allocated_height(display->widget);
    gtk_widget_set_app_paintable(display->widget, TRUE);
    gtk_widget_set_double_buffered(display->widget, TRUE);

    g_signal_connect(display->widget, "draw",
            G_CALLBACK(on_expose), display);

    display->enable_dragging = 0;
    display->is_dragging     = 0;

    return WG_SUCCESS;
}

void
GtkOvgGlue::prepDrawingArea(GtkWidget *drawing_area)
{
    GNASH_REPORT_FUNCTION;

    _drawing_area = drawing_area;
    
    // Disable double buffering, otherwise gtk tries to update widget
    // contents from its internal offscreen buffer at the end of expose event
    gtk_widget_set_double_buffered(_drawing_area, FALSE);

    // EGL needs to be bound to the type of client. The possible
    // clients are OpenVG, OpenGLES1, and OpenGLES2.
    if (_device->getType() == renderer::GnashDevice::EGL) {
        renderer::EGLDevice *egl = (renderer::EGLDevice*)_device.get();
        egl->bindClient(renderer::GnashDevice::OPENVG);
    }
    

    // Attach the window to the low level device
    long xid = GDK_WINDOW_XID(gtk_widget_get_window(drawing_area));
    _device->attachWindow(static_cast<renderer::GnashDevice::native_window_t>
                          (xid));

    //vgLoadIdentity();

#if 0
    renderer::EGLDevice *egl = (renderer::EGLDevice*)_device.get();
    egl->printEGLSurface(eglGetCurrentSurface(EGL_DRAW));
    egl->printEGLContext(eglGetCurrentContext());
#endif
}

/*!
 \brief Initializes the chart attributes to sane defaults
 \param chart is the pointer to the chart object
 */
void mtx_stripchart_init (MtxStripChart *chart)
{
	/* The events the chart receives
	* Need events for button press/release AND motion EVEN THOUGH
	* we don't have a motion handler defined.  It's required for the 
	* dash designer to do drag and move placement 
	*/

	MtxStripChartPrivate *priv = MTX_STRIPCHART_GET_PRIVATE(chart);
	gtk_widget_add_events (GTK_WIDGET (chart),GDK_BUTTON_PRESS_MASK |
			GDK_BUTTON_RELEASE_MASK |
			GDK_POINTER_MOTION_MASK |
			GDK_ENTER_NOTIFY_MASK |
			GDK_LEAVE_NOTIFY_MASK);
        gtk_widget_set_double_buffered (GTK_WIDGET(chart), FALSE);

	priv->num_traces = 0;
	priv->w = 130;		
	priv->h = 20;
	priv->justification = GTK_JUSTIFY_RIGHT;
	priv->font = g_strdup("Bitstream Vera Sans");
	priv->traces = g_array_new(FALSE,TRUE,sizeof(MtxStripChartTrace *));
	mtx_stripchart_init_colors(chart);
/*	if (GTK_WIDGET_REALIZED(chart))
		mtx_stripchart_redraw (chart);
*/
}

MetaImageWindow*
meta_image_window_new (Display *xdisplay,
                       int      screen_number,
                       int      max_width,
                       int      max_height)
{
  MetaImageWindow *iw;
  GdkDisplay *gdisplay;
  GdkScreen *gscreen;

  iw = g_new (MetaImageWindow, 1);
  iw->window = gtk_window_new (GTK_WINDOW_POPUP);

  gdisplay = gdk_x11_lookup_xdisplay (xdisplay);
  gscreen = gdk_display_get_screen (gdisplay, screen_number);

  gtk_window_set_screen (GTK_WINDOW (iw->window), gscreen);

  gtk_widget_realize (iw->window);
  iw->pixmap = gdk_pixmap_new (gtk_widget_get_window (iw->window),
                               max_width, max_height,
                               -1);

  gtk_widget_set_size_request (iw->window, 1, 1);
  gtk_widget_set_double_buffered (iw->window, FALSE);
  gtk_widget_set_app_paintable (iw->window, TRUE);

  return iw;
}

void
gtk_gl_enable (GtkWidget *widget)
{
        GdkScreen *screen;
        GdkVisual *visual;
        Display *xdisplay;
        XVisualInfo *xvi;
        gint xscreen;
        GtkGLContext *gtkgc;
	gint attributes[] ={GLX_RGBA,
                            GLX_RED_SIZE, 8,
                            GLX_GREEN_SIZE, 8,
                            GLX_BLUE_SIZE, 8,
                            GLX_DEPTH_SIZE,24,
                            GLX_DOUBLEBUFFER,
                            None};
        
        gtk_widget_set_app_paintable (widget, TRUE);
        gtk_widget_set_double_buffered (widget, FALSE);

        gtkgc = g_slice_new0 (GtkGLContext);
        
        xdisplay = gdk_x11_get_default_xdisplay ();
        xscreen = gdk_x11_get_default_screen ();
        
        g_return_if_fail (NULL != (xvi = glXChooseVisual (xdisplay, xscreen, attributes)));
        screen = gtk_widget_get_screen (widget);
        g_return_if_fail (NULL != (visual = gdk_x11_screen_lookup_visual (screen, xvi->visualid)));
        gtk_widget_set_visual (widget, visual);
        
        gtkgc->widget  = widget;
        g_return_if_fail (NULL != (gtkgc->context = glXCreateContext (xdisplay, xvi, NULL, GL_TRUE)));
        
        gtk_glx_context_list = g_slist_prepend (gtk_glx_context_list, gtkgc);
}

/**
 * Main GTK Thread.
 * On an actual application, this thread should be started from your app main thread, and not from a video stage
 * This thread will handle all GTK-related functions
 */
DEFINE_THREAD_ROUTINE(gtk, data)
{
    GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

    display_stage_cfg_t *cfg = (display_stage_cfg_t *)data;
    cfg->widget = window;

    g_signal_connect (window, "expose-event", G_CALLBACK (on_expose_event), data);
    g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);

    gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER);
    gtk_window_set_default_size (GTK_WINDOW (window), 10, 10);
    gtk_widget_set_app_paintable (window, TRUE);
    gtk_widget_set_double_buffered (window, FALSE);

    gtk_widget_show_all (window);

    gtkRunning = TRUE;

    gtk_main ();

    gtkRunning = FALSE;

    // Force ardrone_tool to close
    exit_program = 0;

    // Sometimes, ardrone_tool might not finish properly
    // This happens mainly because a thread is blocked on a syscall
    // in this case, wait 5 seconds then kill the app
    sleep (5);
    exit (0);

    return (THREAD_RET)0;
}

cairo_t *init_toolkit(int *argc, char ***argv)
{
	cairo_t *cairo_context;
	cairo_rectangle_int_t rect = { 0, 0, WIN_WIDTH, WIN_HEIGHT };
	int i;

	gtk_init(argc, argv);
	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_widget_set_size_request(window, WIN_WIDTH, WIN_HEIGHT);
	gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
	gtk_window_set_title(GTK_WINDOW(window), WIN_TITLE);
	gtk_widget_set_app_paintable(window, TRUE);
	gtk_widget_set_double_buffered(window, FALSE);
	gtk_widget_add_events(window, GDK_KEY_PRESS_MASK);

	g_signal_connect(window, "destroy", G_CALLBACK(close_window), NULL);
	g_signal_connect(window, "key-press-event", G_CALLBACK(key_pressed), NULL);
	g_signal_connect(window, "draw", G_CALLBACK(redraw), NULL);

	for (i = 0; i < 2; i++) {
		surface[i] = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, WIN_WIDTH, WIN_HEIGHT);
		context[i] = cairo_create(surface[i]);
	}
	current = 0;

	gtk_widget_show(window);

	return context[0];
}

void FullscreenVideoControllerGtk::initializeWindow()
{
    m_window = reinterpret_cast<GtkWidget*>(m_gstreamerGWorld->platformVideoWindow()->window());

    if (!m_hudWindow)
        createHud();

    // Ensure black background.
#ifdef GTK_API_VERSION_2
    GdkColor color = { 1, 0, 0, 0 };
    gtk_widget_modify_bg(m_window, GTK_STATE_NORMAL, &color);
#else
    GdkRGBA color = { 0, 0, 0, 1};
    gtk_widget_override_background_color(m_window, GTK_STATE_FLAG_NORMAL, &color);
#endif
    gtk_widget_set_double_buffered(m_window, FALSE);

    m_keyPressSignalId = g_signal_connect(m_window, "key-press-event", G_CALLBACK(onFullscreenGtkKeyPressEvent), this);
    m_destroySignalId = g_signal_connect(m_window, "destroy", G_CALLBACK(onFullscreenGtkDestroy), this);
    m_isActiveSignalId = g_signal_connect(m_window, "notify::is-active", G_CALLBACK(onFullscreenGtkActiveNotification), this);

    gtk_widget_show_all(m_window);

    GdkWindow* window = gtk_widget_get_window(m_window);
    GRefPtr<GdkCursor> cursor = adoptGRef(gdk_cursor_new(GDK_BLANK_CURSOR));
    gdk_window_set_cursor(window, cursor.get());

    m_motionNotifySignalId = g_signal_connect(m_window, "motion-notify-event", G_CALLBACK(onFullscreenGtkMotionNotifyEvent), this);
    m_configureEventSignalId = g_signal_connect(m_window, "configure-event", G_CALLBACK(onFullscreenGtkConfigureEvent), this);

    gtk_window_fullscreen(GTK_WINDOW(m_window));
    showHud(true);
}

void gui_init(dt_lib_module_t *self)
{
  /* initialize ui widgets */
  dt_lib_navigation_t *d = (dt_lib_navigation_t *)g_malloc0(sizeof(dt_lib_navigation_t));
  self->data = (void *)d;

  /* create drawingarea */
  self->widget = gtk_drawing_area_new();
  gtk_widget_set_events(self->widget, GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK
                                      | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK
                                      | GDK_BUTTON_RELEASE_MASK | GDK_STRUCTURE_MASK);

  /* connect callbacks */
  gtk_widget_set_double_buffered(self->widget, FALSE);
  gtk_widget_set_app_paintable(self->widget, TRUE);
  g_signal_connect(G_OBJECT(self->widget), "expose-event", G_CALLBACK(_lib_navigation_expose_callback), self);
  g_signal_connect(G_OBJECT(self->widget), "button-press-event",
                   G_CALLBACK(_lib_navigation_button_press_callback), self);
  g_signal_connect(G_OBJECT(self->widget), "button-release-event",
                   G_CALLBACK(_lib_navigation_button_release_callback), self);
  g_signal_connect(G_OBJECT(self->widget), "motion-notify-event",
                   G_CALLBACK(_lib_navigation_motion_notify_callback), self);
  g_signal_connect(G_OBJECT(self->widget), "leave-notify-event",
                   G_CALLBACK(_lib_navigation_leave_notify_callback), self);

  /* set size of navigation draw area */
  int panel_width = dt_conf_get_int("panel_width");
  gtk_widget_set_size_request(self->widget, -1, panel_width * .5);

  /* connect a redraw callback to control draw all and preview pipe finish signals */
  dt_control_signal_connect(darktable.signals, DT_SIGNAL_DEVELOP_UI_PIPE_FINISHED,
                            G_CALLBACK(_lib_navigation_control_redraw_callback), self);
  dt_control_signal_connect(darktable.signals, DT_SIGNAL_DEVELOP_PREVIEW_PIPE_FINISHED,
                            G_CALLBACK(_lib_navigation_control_redraw_callback), self);
}

static void
cem_gl_area_configure(GtkWidget *area, gpointer data)
{
  GLint attributes[] = { GLX_RGBA, GLX_DEPTH_SIZE, 24, GLX_DOUBLEBUFFER, None};

  CemGLAreaPrivate *priv;

  gtk_widget_set_double_buffered(area, FALSE);

  priv = cem_gl_area_get_instance_private(area);

  priv->drawing_window = gtk_widget_get_window(GTK_WIDGET(area));

  priv->x_window = gdk_x11_window_get_xid(GDK_WINDOW(priv->drawing_window));

  priv->x_display = gdk_x11_get_default_xdisplay();

  priv->x_visual = glXChooseVisual(priv->x_display, 0, attributes);

  priv->x_context = glXCreateContext(priv->x_display, priv->x_visual, NULL, GL_TRUE);

  XGetWindowAttributes(priv->x_display, priv->x_window, &priv->x_attributes);

  glXMakeCurrent(priv->x_display, priv->x_window, priv->x_context);

  XMapWindow(priv->x_display, priv->x_window);

  glViewport(0, 0, priv->x_attributes.width, priv->x_attributes.height);

  glOrtho(-10, 10, -10, 10, -10, 10);

  glScalef(5.0, 5.0, 5.0);
}

int main (int argc, char** argv)
{
    gtk_init(&argc, &argv);

    _engine.window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_default_size(GTK_WINDOW(_engine.window), 800, 600);
    gtk_window_set_title(GTK_WINDOW(_engine.window), "OpenGL ES2 in GTK2 application");

    gtk_widget_show_all(_engine.window);

    //_egl_init(&_engine);
    //_s52_init(&_engine);

    gtk_widget_set_app_paintable     (_engine.window, TRUE );
    gtk_widget_set_double_buffered   (_engine.window, FALSE);
    gtk_widget_set_redraw_on_allocate(_engine.window, TRUE );

    g_signal_connect(G_OBJECT(_engine.window), "destroy",           G_CALLBACK(gtk_main_quit),      NULL);
    g_signal_connect(G_OBJECT(_engine.window), "key_release_event", G_CALLBACK(_key_release_event), NULL);
    g_signal_connect(G_OBJECT(_engine.window), "configure_event",   G_CALLBACK(_configure_event),   NULL);

    _engine.do_S52init = TRUE;
    g_timeout_add(500, _s52_draw_cb, &_engine); // 0.5 sec

    gtk_main();

    _s52_done(&_engine);
    _egl_done(&_engine);

    g_print("%s .. done\n", argv[0]);

    return 0;
}

int main (int argc, char *argv[]){


    //we need to initialize all these functions so that gtk knows
    //to be thread-aware
    if (!g_thread_supported ()){ g_thread_init(NULL); }
    gdk_threads_init();
    gdk_threads_enter();

    gtk_init(&argc, &argv);

    GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
    g_signal_connect(G_OBJECT(window), "expose_event", G_CALLBACK(on_window_expose_event), NULL);
    g_signal_connect(G_OBJECT(window), "configure_event", G_CALLBACK(on_window_configure_event), NULL);

    //this must be done before we define our pixmap so that it can reference
    //the colour depth and such
    gtk_widget_show_all(window);

    //set up our pixmap so it is ready for drawing
    pixmap = gdk_pixmap_new(window->window,500,500,-1);
    //because we will be painting our pixmap manually during expose events
    //we can turn off gtk's automatic painting and double buffering routines.
    gtk_widget_set_app_paintable(window, TRUE);
    gtk_widget_set_double_buffered(window, FALSE);

    (void)g_timeout_add(33, (GSourceFunc)timer_exe, window);


    gtk_main();
    gdk_threads_leave();

    return 0;
}

static void histogram_view_init(HistogramView *self) {
    /* Double buffering will just slow us down.
     * Turing this off also gives us the chance to paint our own background
     * in the expose handler. Painting it only behind the areas we don't have an
     * image in will make resizing much more speedy and usable.
     */
    gtk_widget_set_double_buffered(GTK_WIDGET(self), FALSE);
}

GtkViewWidget::GtkViewWidget(ZLApplication *application, Angle initialAngle) : ZLViewWidget(initialAngle) {
	myApplication = application;
	myArea = gtk_drawing_area_new();
	myOriginalPixbuf = 0;
	myRotatedPixbuf = 0;
	gtk_widget_set_double_buffered(myArea, false);
	gtk_widget_set_events(myArea, GDK_BUTTON_PRESS_MASK);
}

/*
 * @brief creates all GTK+ widgets that compose the player & sets up callbacks
 * */
static void create_ui(CustomData *data) {
	GtkWidget *main_window; /* uppermost container window */
	GtkWidget *video_window; /* video is shown here */
	GtkWidget *main_box; /* holds hbox & controls */
	GtkWidget *main_hbox; /* hold video window & streaminfo widget */
	GtkWidget *controls; /* hold buttons & slider */
	GtkWidget *play_button, *pause_button, *stop_button;
	GtkCellRenderer     *renderer;

	main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	g_signal_connect(G_OBJECT(main_window), "delete-event", G_CALLBACK(delete_event_cb), data);

	video_window = gtk_drawing_area_new();
	gtk_widget_set_double_buffered(video_window, FALSE);
	g_signal_connect(G_OBJECT(video_window), "realize", G_CALLBACK(realise_cb), data);
	g_signal_connect (video_window, "expose_event", G_CALLBACK (expose_cb), data);

	play_button = gtk_button_new_from_stock (GTK_STOCK_MEDIA_PLAY);
	g_signal_connect (G_OBJECT (play_button), "clicked", G_CALLBACK (play_cb), data);

	pause_button = gtk_button_new_from_stock (GTK_STOCK_MEDIA_PAUSE);
	g_signal_connect (G_OBJECT (pause_button), "clicked", G_CALLBACK (pause_cb), data);

	stop_button = gtk_button_new_from_stock (GTK_STOCK_MEDIA_STOP);
	g_signal_connect (G_OBJECT (stop_button), "clicked", G_CALLBACK (stop_cb), data);

	data->slider = gtk_hscale_new_with_range(0, 100, 1);
	gtk_scale_set_draw_value(GTK_SCALE(data->slider), 0);
	data->slider_update_signal_id = g_signal_connect (G_OBJECT (data->slider), "value-changed", G_CALLBACK (slider_cb), data);

	data->streams_list = gtk_tree_view_new();
	renderer = gtk_cell_renderer_text_new ();
	gtk_cell_renderer_set_fixed_size(renderer, 15, -1);
	gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(data->streams_list),
			-1, "Stream Name", renderer, "text", COL_STREAM_NAME, NULL);
	renderer = gtk_cell_renderer_text_new ();
	gtk_cell_renderer_set_fixed_size(renderer, 15, -1);
	gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(data->streams_list),
			-1, "Stream Details", renderer, "text", COL_STREAM_DETAILS, NULL);
	g_signal_connect(data->streams_list, "row-activated", G_CALLBACK(stream_select_cb), data);
	//gtk_text_view_set_editable (GTK_TEXT_VIEW (data->streams_list), FALSE);

	controls = gtk_hbox_new (FALSE, 0);
	gtk_box_pack_start (GTK_BOX (controls), play_button, FALSE, FALSE, 2);
	gtk_box_pack_start (GTK_BOX (controls), pause_button, FALSE, FALSE, 2);
	gtk_box_pack_start (GTK_BOX (controls), stop_button, FALSE, FALSE, 2);
	gtk_box_pack_start (GTK_BOX (controls), data->slider, TRUE, TRUE, 2);

	main_box = gtk_vbox_new (FALSE, 0);
	gtk_box_pack_start (GTK_BOX (main_box), video_window, TRUE, TRUE, 0);
	gtk_box_pack_start (GTK_BOX (main_box), data->streams_list, FALSE, FALSE, 2);
	gtk_box_pack_start (GTK_BOX (main_box), controls, FALSE, FALSE, 0);
	gtk_container_add (GTK_CONTAINER (main_window), main_box);
	gtk_window_set_default_size (GTK_WINDOW (main_window), 640, 480);

	gtk_widget_show_all (main_window);
}

/**
 * @todo Only from a gtk drawing area ?
 */
glc_drawable_t * glc_gtk_drawable_create( GtkDrawingArea * drawingArea )
{
	assert( drawingArea != 0 && "Calls glc_gtk_drawable_create() with an null drawing area." );

	// Retrieves the window of the drawing area
	GdkWindow *gdkWindow = GTK_WIDGET(drawingArea)->window;

	if( gdkWindow == 0 )
	{
		return 0;
	}
// gdk_window_ensure_native() available from 2.18.0
#if GTKMM_VERSION >= 2180
	else
	{
		// Ensure the gdk window is a window-system native window
		const gboolean isNative = gdk_window_ensure_native( gdkWindow );
		if ( isNative == FALSE )
		{
			assert( false && "Unable to ensure a window-sytem native window" );
			return 0;
		}
		else
		{
	#ifdef WIN32
			EnableWindow( (GLC_WINDOW_HANDLE) GDK_WINDOW_HWND( gdkWindow ), FALSE );
	#endif
		}
	}
#endif

	glc_drawable_t *drawable = (glc_drawable_t*) malloc( sizeof(glc_drawable_t) );
	assert( drawable != 0 && "Unable to allocate glc_drawable_t." );

	// Turns off the double buffering of the widget
	// So clearing to the background color or pixmap will no more happen automatically.
	gtk_widget_set_double_buffered( GTK_WIDGET(drawingArea), FALSE );

	// Initializes the drawable
#ifdef WIN32
	drawable->window	= (GLC_WINDOW_HANDLE) GDK_WINDOW_HWND( gdkWindow );
	drawable->dc		= GetDC( drawable->window );
#else
	#error "Non win32 platform not yet supported."
#endif
	drawable->backend			= (drawable_backend_t*) malloc( sizeof(drawable_backend_t) );
	drawable->backend->destroy	= &glc_gtk_drawable_destroy;

	_glc_drawable_initialize( drawable );

	// @todo glc_gtk_drawable_status()
	assert( drawable->window != 0 );
	assert( drawable->dc != 0 );
	assert( drawable->backend != 0 );

	return drawable;
}