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;
}
GuiDrawingArea GuiDrawingArea_create (GuiForm parent, int left, int right, int top, int bottom,
void (*exposeCallback) (void *boss, GuiDrawingAreaExposeEvent event),
void (*clickCallback) (void *boss, GuiDrawingAreaClickEvent event),
void (*keyCallback) (void *boss, GuiDrawingAreaKeyEvent event),
void (*resizeCallback) (void *boss, GuiDrawingAreaResizeEvent event), void *boss,
unsigned long flags)
{
GuiDrawingArea me = Thing_new (GuiDrawingArea);
my d_shell = parent -> d_shell;
my d_parent = parent;
my d_exposeCallback = exposeCallback;
my d_exposeBoss = boss;
my d_clickCallback = clickCallback;
my d_clickBoss = boss;
my d_keyCallback = keyCallback;
my d_keyBoss = boss;
my d_resizeCallback = resizeCallback;
my d_resizeBoss = boss;
#if gtk
my d_widget = gtk_drawing_area_new ();
GdkEventMask mask = (GdkEventMask) (GDK_EXPOSURE_MASK // receive exposure events
| GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK // receive click events
| GDK_BUTTON_MOTION_MASK // receive motion notifies when a button is pressed
| GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK
| GDK_POINTER_MOTION_HINT_MASK); // receive fewer motion notify events (the cb might take time)
gtk_widget_set_events (GTK_WIDGET (my d_widget), mask);
g_signal_connect (G_OBJECT (my d_widget), "expose-event", G_CALLBACK (_GuiGtkDrawingArea_exposeCallback), me);
g_signal_connect (G_OBJECT (my d_widget), "destroy", G_CALLBACK (_GuiGtkDrawingArea_destroyCallback), me);
g_signal_connect (G_OBJECT (my d_widget), "button-press-event", G_CALLBACK (_GuiGtkDrawingArea_clickCallback), me);
g_signal_connect (G_OBJECT (my d_widget), "button-release-event", G_CALLBACK (_GuiGtkDrawingArea_clickCallback), me);
g_signal_connect (G_OBJECT (my d_widget), "motion-notify-event", G_CALLBACK (_GuiGtkDrawingArea_clickCallback), me);
if (parent != NULL) {
Melder_assert (parent -> d_widget);
g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (GTK_WIDGET (parent -> d_widget))), "key-press-event",
G_CALLBACK (_GuiGtkDrawingArea_keyCallback), me);
}
g_signal_connect (G_OBJECT (my d_widget), "size-allocate", G_CALLBACK (_GuiGtkDrawingArea_resizeCallback), me);
// g_signal_connect (GTK_WIDGET (my d_widget), "activate", G_CALLBACK (_GuiGtkDrawingArea_activateCallback), me);
_GuiObject_setUserData (my d_widget, me);
my v_positionInForm (my d_widget, left, right, top, bottom, parent);
gtk_widget_set_double_buffered (GTK_WIDGET (my d_widget), FALSE);
#elif cocoa
#elif win
my d_widget = _Gui_initializeWidget (xmDrawingAreaWidgetClass, parent -> d_widget, L"drawingArea");
_GuiObject_setUserData (my d_widget, me);
my d_widget -> window = CreateWindowEx (0, _GuiWin_getDrawingAreaClassName (), L"drawingArea",
WS_CHILD | WS_BORDER | WS_CLIPSIBLINGS,
my d_widget -> x, my d_widget -> y, my d_widget -> width, my d_widget -> height, my d_widget -> parent -> window, NULL, theGui.instance, NULL);
SetWindowLongPtr (my d_widget -> window, GWLP_USERDATA, (LONG_PTR) my d_widget);
my v_positionInForm (my d_widget, left, right, top, bottom, parent);
#elif mac
my d_widget = _Gui_initializeWidget (xmDrawingAreaWidgetClass, parent -> d_widget, L"drawingArea");
_GuiObject_setUserData (my d_widget, me);
my v_positionInForm (my d_widget, left, right, top, bottom, parent);
#endif
return me;
}
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;
}
void
GtkAggGlue::prepDrawingArea(GtkWidget *drawing_area)
{
_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);
}
//================================================================
void* GLB_Create () {
//================================================================
/// GLB_Create create opengl-window (used by GUI_gl__)
GtkWidget *area;
int xscreen, i1;
GdkScreen *screen;
GdkVisual *visual;
Window root;
XVisualInfo *xvisual;
Colormap xcolormap;
int attributes[] = {
GLX_RGBA,
GLX_RED_SIZE, 1,
GLX_GREEN_SIZE, 1,
GLX_BLUE_SIZE, 1,
GLX_DOUBLEBUFFER, True,
GLX_DEPTH_SIZE, 24,
None };
GLB_x_id = 0; // reset
area = gtk_drawing_area_new ();
gtk_widget_set_double_buffered (area, FALSE);
GLB_display = gdk_x11_get_default_xdisplay ();
xscreen = DefaultScreen (GLB_display);
screen = gdk_screen_get_default ();
// printf(" screenNr = %d\n",gdk_screen_get_number(screen));
xvisual = glXChooseVisual (GLB_display, xscreen, attributes);
// printf(" xvisualid=%d\n",xvisual->visualid);
visual = gdk_x11_screen_lookup_visual (screen, xvisual->visualid);
root = RootWindow (GLB_display, xscreen);
xcolormap = XCreateColormap (GLB_display, root, xvisual->visual, AllocNone);
glXGetConfig (GLB_display, xvisual, GLX_RED_SIZE, &i1);
printf(" GLX_RED_SIZE=%d\n",i1);
glXGetConfig (GLB_display, xvisual, GLX_DEPTH_SIZE, &i1);
printf(" GLX_DEPTH_SIZE=%d\n",i1);
// Gtk2 only:
//colormap = gdk_x11_colormap_foreign_new (visual, xcolormap);
//gtk_widget_set_colormap (area, colormap);
GLB_x_context = glXCreateContext (GLB_display, xvisual, NULL, TRUE);
// free (xvisual);
glXWaitX();
glXWaitGL();
return area;
}
gboolean GTKVideo::create_ui(void *user_data) {
GTKVideo *context = static_cast<GTKVideo *>(user_data);
context->display_ = gdk_display_get_default();
if (nullptr == context->display_) {
g_debug("gtkvideo: no default display, cannot create window");
std::unique_lock<std::mutex> lock(context->wait_window_mutex_);
context->wait_window_cond_.notify_all();
return FALSE;
}
context->main_window_ = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect(G_OBJECT(context->main_window_),
"delete-event", G_CALLBACK(delete_event_cb), context);
context->video_window_ = gtk_drawing_area_new();
gtk_widget_set_double_buffered(context->video_window_, FALSE);
GdkColor color;
gdk_color_parse("black", &color);
gtk_widget_modify_bg(context->video_window_, GTK_STATE_NORMAL, &color);
g_signal_connect(context->video_window_, "realize",
G_CALLBACK(realize_cb), context);
g_signal_connect (context->video_window_,
"motion-notify-event",
G_CALLBACK (GTKVideo::motion_notify_event), context);
g_signal_connect (context->video_window_,
"button-press-event",
G_CALLBACK (GTKVideo::button_event), context);
g_signal_connect (context->video_window_,
"button-release-event",
G_CALLBACK (GTKVideo::button_event), context);
g_signal_connect(context->video_window_,
"size-allocate",
G_CALLBACK(widget_getsize), context);
gtk_widget_set_events (context->video_window_,
GDK_EXPOSURE_MASK
| GDK_LEAVE_NOTIFY_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_POINTER_MOTION_MASK
| GDK_POINTER_MOTION_HINT_MASK);
gtk_container_add(GTK_CONTAINER(context->main_window_),
context->video_window_);
gtk_window_set_default_size(GTK_WINDOW(context->main_window_), 640, 480);
gtk_window_set_title(GTK_WINDOW(context->main_window_), context->title_);
context->blank_cursor_ = gdk_cursor_new(GDK_BLANK_CURSOR);
gtk_widget_set_events(context->main_window_, GDK_KEY_PRESS_MASK);
g_signal_connect(G_OBJECT(context->main_window_),
"key-press-event",
G_CALLBACK(GTKVideo::key_pressed_cb),
context);
g_signal_connect(G_OBJECT(context->main_window_),
"key-release-event",
G_CALLBACK(GTKVideo::key_release_cb),
context);
gtk_widget_show_all((GtkWidget *) context->main_window_);
return FALSE;
}
bool C4Window::ReInit(C4AbstractApp* pApp)
{
// Check whether multisampling settings was changed. If not then we
// don't need to ReInit anything.
#ifdef GDK_WINDOWING_X11
int value;
Display * const dpy = gdk_x11_display_get_xdisplay(gdk_display_get_default());
glXGetFBConfigAttrib(dpy, Info, GLX_SAMPLES, &value);
if(value == Config.Graphics.MultiSampling) return true;
// Check whether we have a visual with the requested number of samples
GLXFBConfig new_info;
if(!FindFBConfig(Config.Graphics.MultiSampling, &new_info)) return false;
GdkScreen * scr = gtk_widget_get_screen(GTK_WIDGET(render_widget));
XVisualInfo *vis_info = glXGetVisualFromFBConfig(dpy, new_info);
assert(vis_info);
GdkVisual * vis = gdk_x11_screen_lookup_visual(scr, vis_info->visualid);
XFree(vis_info);
// Un- and re-realizing the render_widget does not work, the window
// remains hidden afterwards. So we re-create it from scratch.
gtk_widget_destroy(GTK_WIDGET(render_widget));
render_widget = gtk_drawing_area_new();
#if !GTK_CHECK_VERSION(3,10,0)
gtk_widget_set_double_buffered (GTK_WIDGET(render_widget), false);
#endif
g_object_set(G_OBJECT(render_widget), "can-focus", TRUE, NULL);
gtk_widget_set_visual(GTK_WIDGET(render_widget),vis);
Info = new_info;
// Wait until window is mapped to get the window's XID
gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(render_widget));
gtk_widget_show_now(GTK_WIDGET(render_widget));
if (GTK_IS_LAYOUT(render_widget))
{
GdkWindow* bin_wnd = gtk_layout_get_bin_window(GTK_LAYOUT(render_widget));
renderwnd = GDK_WINDOW_XID(bin_wnd);
}
else
{
GdkWindow* render_wnd = gtk_widget_get_window(GTK_WIDGET(render_widget));
renderwnd = GDK_WINDOW_XID(render_wnd);
}
gdk_flush();
gdk_window_set_cursor(gtk_widget_get_window(GTK_WIDGET(render_widget)),
gdk_cursor_new_for_display(gdk_display_get_default(), GDK_BLANK_CURSOR));
return true;
#endif
}
static void
na_tray_child_realize (GtkWidget *widget)
{
NaTrayChild *child = NA_TRAY_CHILD (widget);
GdkVisual *visual = gtk_widget_get_visual (widget);
GdkWindow *window;
GTK_WIDGET_CLASS (na_tray_child_parent_class)->realize (widget);
window = gtk_widget_get_window (widget);
if (child->has_alpha)
{
/* We have real transparency with an ARGB visual and the Composite
* extension. */
/* Set a transparent background */
GdkColor transparent = { 0, 0, 0, 0 }; /* only pixel=0 matters */
gdk_window_set_background (window, &transparent);
gdk_window_set_composited (window, TRUE);
child->parent_relative_bg = FALSE;
}
#if GTK_CHECK_VERSION(3, 0, 0)
else if (visual == gdk_window_get_visual(gdk_window_get_parent(window)))
#else
else if (visual == gdk_drawable_get_visual(GDK_DRAWABLE(gdk_window_get_parent(window))))
#endif
{
/* Otherwise, if the visual matches the visual of the parent window, we
* can use a parent-relative background and fake transparency. */
gdk_window_set_back_pixmap (window, NULL, TRUE);
child->parent_relative_bg = TRUE;
}
else
{
/* Nothing to do; the icon will sit on top of an ugly gray box */
child->parent_relative_bg = FALSE;
}
gdk_window_set_composited (window, child->composited);
gtk_widget_set_app_paintable (GTK_WIDGET (child),
child->parent_relative_bg || child->has_alpha);
/* Double-buffering will interfere with the parent-relative-background fake
* transparency, since the double-buffer code doesn't know how to fill in the
* background of the double-buffer correctly.
*/
gtk_widget_set_double_buffered (GTK_WIDGET (child),
child->parent_relative_bg);
}
void
GtkAggVaapiGlue::prepDrawingArea(GtkWidget *drawing_area)
{
dprintf("GtkAggVaapiGlue::prepDrawingArea()\n");
_drawing_area = drawing_area;
// Disable double buffering. Otherwise, Gtk tries to update widget
// contents from its internal offscreen buffer at the end of
// expose events
gtk_widget_set_double_buffered(_drawing_area, FALSE);
}
static void
ubiquity_webcam_init (UbiquityWebcam *self) {
UbiquityWebcamPrivate *priv;
gint width = 172, height = 129;
assert (width * 3 == height * 4); /* 4x3 ratio */
priv = self->priv = UBIQUITY_WEBCAM_PRIVATE (self);
gtk_orientable_set_orientation (GTK_ORIENTABLE (self),
GTK_ORIENTATION_VERTICAL);
gtk_box_set_spacing (GTK_BOX (self), 1);
priv->drawing_area = gtk_drawing_area_new ();
gtk_widget_set_size_request (priv->drawing_area, width, height);
g_signal_connect (priv->drawing_area, "realize",
G_CALLBACK(drawing_area_realized_cb), NULL);
gtk_widget_set_double_buffered (priv->drawing_area, FALSE);
priv->button = gtk_button_new ();
gtk_button_set_label (GTK_BUTTON (priv->button), "Take Photo");
gtk_box_pack_start (GTK_BOX (self), priv->drawing_area, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (self), priv->button, FALSE, FALSE, 0);
priv->camerabin = gst_element_factory_make ("camerabin2" , "cam");
priv->viewfinder_caps = gst_caps_new_simple ("video/x-raw-rgb",
"width", G_TYPE_INT, 640,
"height", G_TYPE_INT, 480, NULL);
g_object_set (G_OBJECT (priv->camerabin),
"viewfinder-caps", priv->viewfinder_caps, NULL);
g_signal_new ("image-captured",
UBIQUITY_TYPE_WEBCAM,
G_SIGNAL_RUN_FIRST,
0,
NULL,
NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE, 1,
G_TYPE_STRING);
if (!priv->camerabin) {
g_print ("Failed to create camerabin.\n");
return;
}
g_signal_connect (priv->button, "clicked",
G_CALLBACK(button_clicked_cb), priv->camerabin);
priv->bus = gst_element_get_bus (priv->camerabin);
gst_bus_add_signal_watch (priv->bus);
g_signal_connect (priv->bus, "message", G_CALLBACK (message_cb), self);
gst_bus_set_sync_handler (priv->bus, (GstBusSyncHandler) window_id_cb, NULL);
gst_object_ref (priv->bus);
gst_object_ref (priv->camerabin);
}
int main(int argc, char **argv)
{
gfx_context *ctx = NULL;
GtkWidget *window = NULL;
gfx_text_layout* text = NULL;
int r;
/* Initialization */
gfx_init(&argc, &argv);
gtk_init(&argc, &argv);
ctx = gfx_context_new(NULL);
gfx_context_make_current(ctx);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
canvas = gtk_drawing_area_new();
gtk_window_set_default_size(GTK_WINDOW(window), 640,480);
gtk_widget_set_double_buffered(canvas, FALSE);
gtk_widget_set_events(canvas, GDK_EXPOSURE_MASK);
gtk_widget_realize(GTK_WIDGET(window));
gtk_container_add(GTK_CONTAINER(window), canvas);
gtk_widget_show_all(GTK_WIDGET(window));
/* Create a new framebuffer to draw */
fb = gfx_framebuffer_new(640, 480, GFX_PIXELFORMAT_BGRA32, 0, 0);
gfx_framebuffer_bind(fb);
text = gfx_text_layout_new(640, 480);
gfx_framebuffer_attach_texture(GFX_ATTACH_COLOR_BUFFER, (gfx_texture*)text);
gfx_text_layout_set_pango_markup(text, "<span font='Sans 32'>あいうえお\nかきくけこ</span>");
gfx_text_layout_set_background(text, 0.0, 0.0, 1.0, 1.0);
gfx_text_layout_set_foreground(text, 1.0, 1.0, 0.0, 1.0);
gfx_text_layout_set_alignment(text, PANGO_ALIGN_CENTER);
gfx_text_layout_set_indent(text, 100);
gfx_text_layout_set_line_spacing(text, 100);
gfx_text_layout_render(text);
g_signal_connect(window, "destroy", gtk_main_quit, NULL);
g_signal_connect(canvas, "expose-event", G_CALLBACK(glcanvas_handler), NULL);
gtk_main();
/* Release resource */
gfx_text_layout_delete(&text);
gfx_framebuffer_delete(&fb);
gfx_context_delete(&ctx);
return EXIT_SUCCESS;
}
static int gtkCanvasSetBgColorAttrib(Ihandle* ih, const char* value)
{
GtkWidget* sb_win = (GtkWidget*)iupAttribGet(ih, "_IUP_EXTRAPARENT");
unsigned char r, g, b;
/* ignore given value, must use only from parent for the scrollbars */
char* parent_value = iupBaseNativeParentGetBgColor(ih);
if (iupStrToRGB(parent_value, &r, &g, &b))
{
GtkWidget* sb;
iupgtkSetBgColor(sb_win, r, g, b);
sb = (GtkWidget*)iupAttribGet(ih, "_IUPGTK_SBHORIZ");
if (sb) iupgtkSetBgColor(sb, r, g, b);
sb = (GtkWidget*)iupAttribGet(ih, "_IUPGTK_SBVERT");
if (sb) iupgtkSetBgColor(sb, r, g, b);
}
if (!IupGetCallback(ih, "ACTION"))
{
/* enable automatic double buffering */
gtk_widget_set_double_buffered(ih->handle, TRUE);
gtk_widget_set_double_buffered(sb_win, TRUE);
return iupdrvBaseSetBgColorAttrib(ih, value);
}
else
{
/* disable automatic double buffering */
gtk_widget_set_double_buffered(ih->handle, FALSE);
gtk_widget_set_double_buffered(sb_win, FALSE);
#if !GTK_CHECK_VERSION(3, 0, 0)
gdk_window_set_back_pixmap(iupgtkGetWindow(ih->handle), NULL, FALSE);
#endif
iupAttribSetStr(ih, "_IUPGTK_NO_BGCOLOR", "1");
return 1;
}
}
