void
moz_drawingarea_create_windows (MozDrawingarea *drawingarea, GdkWindow *parent,
GtkWidget *widget, GdkVisual *visual)
{
GdkWindowAttr attributes;
gint attributes_mask = 0;
/* create the clipping window */
attributes.event_mask = 0;
attributes.x = 0;
attributes.y = 0;
attributes.width = 1;
attributes.height = 1;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.window_type = GDK_WINDOW_CHILD;
if (!visual) {
attributes.visual = gtk_widget_get_visual (widget);
attributes.colormap = gtk_widget_get_colormap (widget);
} else {
attributes.visual = visual;
attributes.colormap = gdk_colormap_new(visual, 0);
}
attributes_mask |= GDK_WA_VISUAL | GDK_WA_COLORMAP |
GDK_WA_X | GDK_WA_Y;
drawingarea->clip_window = gdk_window_new (parent, &attributes,
attributes_mask);
gdk_window_set_user_data(drawingarea->clip_window, widget);
/* set the default pixmap to None so that you don't end up with the
gtk default which is BlackPixel. */
gdk_window_set_back_pixmap(drawingarea->clip_window, NULL, FALSE);
attributes.event_mask = (GDK_EXPOSURE_MASK | GDK_STRUCTURE_MASK |
GDK_VISIBILITY_NOTIFY_MASK |
GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK |
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK);
/* create the inner window */
drawingarea->inner_window = gdk_window_new (drawingarea->clip_window,
&attributes, attributes_mask);
gdk_window_set_user_data(drawingarea->inner_window, widget);
g_object_weak_ref(G_OBJECT(widget), nullify_widget_pointers, drawingarea);
/* set the default pixmap to None so that you don't end up with the
gtk default which is BlackPixel. */
gdk_window_set_back_pixmap(drawingarea->inner_window, NULL, FALSE);
if (visual) {
g_object_unref(attributes.colormap);
}
}
static void sanalyzer_init(void)
{
GdkColor color;
int i;
if(window)
return;
window = gtk_window_new(GTK_WINDOW_DIALOG);
gtk_window_set_title(GTK_WINDOW(window),_("Spectrum analyzer"));
gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, FALSE);
gtk_widget_realize(window);
bg_pixmap = gdk_pixmap_create_from_xpm_d(window->window,NULL,NULL,sanalyzer_xmms_logo_xpm);
gdk_window_set_back_pixmap(window->window,bg_pixmap,0);
gtk_signal_connect(GTK_OBJECT(window),"destroy",GTK_SIGNAL_FUNC(sanalyzer_destroy_cb),NULL);
gtk_signal_connect(GTK_OBJECT(window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window);
gtk_widget_set_usize(window, WIDTH, HEIGHT);
gc = gdk_gc_new(window->window);
draw_pixmap = gdk_pixmap_new(window->window,WIDTH,HEIGHT,gdk_rgb_get_visual()->depth);
bar = gdk_pixmap_new(window->window,25, HEIGHT, gdk_rgb_get_visual()->depth);
for(i = 0; i < HEIGHT / 2; i++)
{
color.red = 0xFFFF;
color.green = ((i * 255) / (HEIGHT / 2)) << 8;
color.blue = 0;
gdk_color_alloc(gdk_colormap_get_system(),&color);
gdk_gc_set_foreground(gc,&color);
gdk_draw_line(bar,gc,0,i,24,i);
}
for(i = 0; i < HEIGHT / 2; i++)
{
color.red = (255 - ((i * 255) / (HEIGHT / 2))) <<8;
color.green = 0xFFFF;
color.blue = 0;
gdk_color_alloc(gdk_colormap_get_system(),&color);
gdk_gc_set_foreground(gc,&color);
gdk_draw_line(bar,gc,0,i + (HEIGHT / 2),24,i + (HEIGHT / 2));
}
scale = HEIGHT / log(256);
gdk_color_black(gdk_colormap_get_system(),&color);
gdk_gc_set_foreground(gc,&color);
area = gtk_drawing_area_new();
gtk_container_add(GTK_CONTAINER(window),area);
gtk_widget_realize(area);
gdk_window_set_back_pixmap(area->window,bg_pixmap,0);
gtk_widget_show(area);
gtk_widget_show(window);
gdk_window_clear(window->window);
gdk_window_clear(area->window);
}
void
theme_set_background(GtkStyle * style,
GdkWindow * window,
GtkStateType state_type)
{
GdkPixmap *pixmap;
gint parent_relative;
g_return_if_fail(style != NULL);
g_return_if_fail(window != NULL);
if (style->bg_pixmap[state_type])
{
if (style->bg_pixmap[state_type] == (GdkPixmap *) GDK_PARENT_RELATIVE)
{
pixmap = NULL;
parent_relative = TRUE;
}
else
{
pixmap = style->bg_pixmap[state_type];
parent_relative = FALSE;
}
gdk_window_set_back_pixmap(window, pixmap, parent_relative);
}
else
gdk_window_set_background(window, &style->bg[state_type]);
}
/**
* mate_bg_crossfade_start:
* @fade: a #MateBGCrossfade
* @window: The #GdkWindow to draw crossfade on
*
* This function initiates a quick crossfade between two pixmaps on
* the background of @window. Before initiating the crossfade both
* mate_bg_crossfade_start() and mate_bg_crossfade_end() need to
* be called. If animations are disabled, the crossfade is skipped,
* and the window background is set immediately to the end pixmap.
**/
void
mate_bg_crossfade_start (MateBGCrossfade *fade,
GdkWindow *window)
{
GSource *source;
GMainContext *context;
g_return_if_fail (MATE_IS_BG_CROSSFADE (fade));
g_return_if_fail (window != NULL);
g_return_if_fail (fade->priv->fading_pixmap != NULL);
g_return_if_fail (fade->priv->end_pixmap != NULL);
g_return_if_fail (!mate_bg_crossfade_is_started (fade));
g_return_if_fail (GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN);
source = g_timeout_source_new (1000 / 60.0);
g_source_set_callback (source,
(GSourceFunc) on_tick,
fade,
(GDestroyNotify) on_finished);
context = g_main_context_default ();
fade->priv->timeout_id = g_source_attach (source, context);
g_source_unref (source);
fade->priv->window = window;
gdk_window_set_back_pixmap (fade->priv->window,
fade->priv->fading_pixmap,
FALSE);
draw_background (fade);
fade->priv->is_first_frame = TRUE;
fade->priv->total_duration = .75;
fade->priv->start_time = get_current_time ();
}
gboolean
expose_cb (GtkWidget *widget, GdkEventExpose *event, gpointer data)
{
GdkPixbuf *dest;
gdk_window_set_back_pixmap (widget->window, NULL, FALSE);
dest = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, event->area.width, event->area.height);
gdk_pixbuf_composite_color (pixbuf, dest,
0, 0, event->area.width, event->area.height,
-event->area.x, -event->area.y,
(double) widget->allocation.width / gdk_pixbuf_get_width (pixbuf),
(double) widget->allocation.height / gdk_pixbuf_get_height (pixbuf),
interp_type, overall_alpha,
event->area.x, event->area.y, 16, 0xaaaaaa, 0x555555);
gdk_pixbuf_render_to_drawable (dest, widget->window, widget->style->fg_gc[GTK_STATE_NORMAL],
0, 0, event->area.x, event->area.y,
event->area.width, event->area.height,
GDK_RGB_DITHER_NORMAL, event->area.x, event->area.y);
gdk_pixbuf_unref (dest);
return TRUE;
}
static void zbar_gtk_realize (GtkWidget *widget)
{
ZBarGtk *self = ZBAR_GTK(widget);
if(!self->_private)
return;
ZBarGtkPrivate *zbar = ZBAR_GTK_PRIVATE(self->_private);
GTK_WIDGET_UNSET_FLAGS(widget, GTK_DOUBLE_BUFFERED);
GTK_WIDGET_SET_FLAGS(widget, GTK_REALIZED);
GdkWindowAttr attributes;
attributes.x = widget->allocation.x;
attributes.y = widget->allocation.y;
attributes.width = widget->allocation.width;
attributes.height = widget->allocation.height;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.window_type = GDK_WINDOW_CHILD;
attributes.event_mask = (gtk_widget_get_events(widget) |
GDK_EXPOSURE_MASK);
widget->window = gdk_window_new(gtk_widget_get_parent_window(widget),
&attributes,
GDK_WA_X | GDK_WA_Y);
gdk_window_set_user_data(widget->window, widget);
gdk_window_set_back_pixmap(widget->window, NULL, TRUE);
/* attach zbar_window to underlying X window */
if(zbar_window_attach(zbar->window,
gdk_x11_drawable_get_xdisplay(widget->window),
gdk_x11_drawable_get_xid(widget->window)))
zbar_window_error_spew(zbar->window, 0);
}
void
meta_image_window_set (MetaImageWindow *iw,
GdkPixbuf *pixbuf,
int x,
int y)
{
/* We use a back pixmap to avoid having to handle exposes, because
* it's really too slow for large clients being minimized, etc.
* and this way flicker is genuinely zero.
*/
gdk_draw_pixbuf (iw->pixmap,
iw->window->style->black_gc,
pixbuf,
0, 0,
0, 0,
gdk_pixbuf_get_width (pixbuf),
gdk_pixbuf_get_height (pixbuf),
GDK_RGB_DITHER_NORMAL,
0, 0);
gdk_window_set_back_pixmap (iw->window->window,
iw->pixmap,
FALSE);
gdk_window_move_resize (iw->window->window,
x, y,
gdk_pixbuf_get_width (pixbuf),
gdk_pixbuf_get_height (pixbuf));
gdk_window_clear (iw->window->window);
}
/*!
Display a selection of the color image \e I in RGBa format (32bits).
\warning Display has to be initialized.
\warning Suppress the overlay drawing in the region of interest.
\param I : Image to display.
\param iP : Top left corner of the region of interest
\param w : Width of the region of interest
\param h : Height of the region of interest
\sa init(), closeDisplay()
*/
void vpDisplayGTK::displayImageROI ( const vpImage<vpRGBa> &I,const vpImagePoint &iP, const unsigned int w, const unsigned int h )
{
if (displayHasBeenInitialized)
{
vpImage<vpRGBa> Itemp;
vpImageTools::crop(I,(unsigned int)iP.get_i(), (unsigned int)iP.get_j(), h, w, Itemp);
/* Copie de l'image dans le pixmap fond */
gdk_draw_rgb_32_image(background,
gc, (gint)iP.get_u(), (gint)iP.get_v(), (gint)w, (gint)h,
GDK_RGB_DITHER_NONE,
(unsigned char *)Itemp.bitmap,
(gint)(4*w));
/* Permet de fermer la fenetre si besoin (cas des sequences d'images) */
//while (g_main_iteration(FALSE));
/* Le pixmap background devient le fond de la zone de dessin */
gdk_window_set_back_pixmap(widget->window, background, FALSE);
/* Affichage */
//gdk_window_clear(GTK_WINDOW(widget));
//flushDisplay() ;
}
else
{
vpERROR_TRACE("GTK not initialized " ) ;
throw(vpDisplayException(vpDisplayException::notInitializedError,
"GTK not initialized")) ;
}
}
static void
set_app_window(HippoWindowGtk *window_gtk,
gboolean app_window)
{
GtkWindow *window = GTK_WINDOW(window_gtk);
GtkWidget *widget = GTK_WIDGET(window_gtk);
app_window = app_window != FALSE;
if (window_gtk->app_window == app_window)
return;
window_gtk->app_window = app_window;
gtk_window_set_skip_taskbar_hint(window, !app_window);
gtk_window_set_skip_pager_hint(window, !app_window);
if (app_window) {
gtk_window_set_type_hint(window, GDK_WINDOW_TYPE_HINT_NORMAL);
gtk_window_set_accept_focus(window, TRUE);
} else {
/* NOTIFICATION is the right type hint, but that's new in GTK+-2.10 */
gtk_window_set_type_hint(window, GDK_WINDOW_TYPE_HINT_DOCK);
gtk_window_set_accept_focus(window, FALSE);
}
/* See note about "background none" in hippo_window_gtk_realize() */
if (GTK_WIDGET_REALIZED(widget)) {
if (app_window) {
/* This should cause the right pixel to be set, replacing background-none */
gtk_style_set_background (widget->style, widget->window, widget->state);
} else {
gdk_window_set_back_pixmap(widget->window, NULL, FALSE);
}
}
}
/*!
Display a selection of the gray level image \e I (8bits).
\warning Display has to be initialized.
\warning Suppress the overlay drawing in the region of interest.
\param I : Image to display.
\param iP : Top left corner of the region of interest
\param w : Width of the region of interest
\param h : Height of the region of interest
\sa init(), closeDisplay()
*/
void vpDisplayGTK::displayImageROI ( const vpImage<unsigned char> &I,const vpImagePoint &iP, const unsigned int w, const unsigned int h )
{
if (displayHasBeenInitialized)
{
vpImage<unsigned char> Itemp;
vpImageTools::crop(I,(unsigned int)iP.get_i(),(unsigned int)iP.get_j(), h, w,Itemp);
/* Copie de l'image dans le pixmap fond */
gdk_draw_gray_image(background,
gc, (gint)iP.get_u(), (gint)iP.get_v(), (gint)w, (gint)h,
GDK_RGB_DITHER_NONE,
I.bitmap,
(gint)w);
/* Le pixmap background devient le fond de la zone de dessin */
gdk_window_set_back_pixmap(widget->window, background, FALSE);
/* Affichage */
//gdk_window_clear(GTK_WINDOW(widget));
//gdk_flush();
}
else
{
vpERROR_TRACE("GTK not initialized " ) ;
throw(vpDisplayException(vpDisplayException::notInitializedError,
"GTK not initialized")) ;
}
}
/*!
Display the color image \e I in RGBa format (32bits).
\warning Display has to be initialized.
\warning Suppress the overlay drawing.
\param I : Image to display.
\sa init(), closeDisplay()
*/
void vpDisplayGTK::displayImage(const vpImage<vpRGBa> &I)
{
if (displayHasBeenInitialized)
{
/* Copie de l'image dans le pixmap fond */
gdk_draw_rgb_32_image(background,
gc, 0, 0, (gint)width, (gint)height,
GDK_RGB_DITHER_NONE,
(unsigned char *)I.bitmap,
(gint)(4*width));
/* Permet de fermer la fenetre si besoin (cas des sequences d'images) */
//while (g_main_iteration(FALSE));
/* Le pixmap background devient le fond de la zone de dessin */
gdk_window_set_back_pixmap(widget->window, background, FALSE);
/* Affichage */
//gdk_window_clear(GTK_WINDOW(widget));
//flushDisplay() ;
}
else
{
vpERROR_TRACE("GTK not initialized " ) ;
throw(vpDisplayException(vpDisplayException::notInitializedError,
"GTK not initialized")) ;
}
}
static void
gb_custom_on_widget_realize (GtkWidget *widget, gpointer data)
{
static GdkPixmap *background_pixmap = NULL;
#if 0
g_print ("In gb_custom_on_widget_realize widget:%s (%p)\n",
gtk_widget_get_name (widget), widget);
#endif
/* Create the background pixmap if it hasn't already been created. */
if (background_pixmap == NULL)
{
background_pixmap = gdk_pixmap_create_from_xpm_d (widget->window,
NULL, NULL,
custom_bg_xpm);
if (!background_pixmap)
{
g_warning ("Couldn't create background pixmap\n");
/* FIXME: Use a color instead? */
}
}
if (background_pixmap != NULL)
gdk_window_set_back_pixmap (widget->window, background_pixmap, FALSE);
}
/*!
Display the gray level image \e I (8bits).
\warning Display has to be initialized.
\warning Suppress the overlay drawing.
\param I : Image to display.
\sa init(), closeDisplay()
*/
void vpDisplayGTK::displayImage(const vpImage<unsigned char> &I)
{
if (displayHasBeenInitialized)
{
/* Copie de l'image dans le pixmap fond */
gdk_draw_gray_image(background,
gc, 0, 0, (gint)width, (gint)height,
GDK_RGB_DITHER_NONE,
I.bitmap,
(gint)width);
/* Le pixmap background devient le fond de la zone de dessin */
gdk_window_set_back_pixmap(widget->window, background, FALSE);
/* Affichage */
//gdk_window_clear(GTK_WINDOW(widget));
//gdk_flush();
}
else
{
vpERROR_TRACE("GTK not initialized " ) ;
throw(vpDisplayException(vpDisplayException::notInitializedError,
"GTK not initialized")) ;
}
}
static void
hippo_window_gtk_realize(GtkWidget *widget)
{
HippoWindowGtk *window_gtk = HIPPO_WINDOW_GTK(widget);
GTK_WIDGET_CLASS(hippo_window_gtk_parent_class)->realize(widget);
/* Static bit gravity means that when we are simultaneously moved
* and resized, the windowing system should just leave our image
* bits where they were before. This prevents bouncing of elements
* that are glued to a right/bottom edge that doesn't move -
* otherwise the windowing system would move the bits, then we'd
* redraw them back where they were before.
*/
set_static_bit_gravity(widget);
/* When we are a notification window (not an "app window") then
* we'll never get exposed by someone dragging another window
* on top, so it will work well to use a background of "none";
* this considerably improves the appearance when we are
* spontaneously resizing, since you don't get a blank area first.
*/
if (!window_gtk->app_window)
gdk_window_set_back_pixmap(widget->window, NULL, FALSE);
}
static void
on_finished (MateBGCrossfade *fade)
{
if (fade->priv->timeout_id == 0)
return;
g_assert (fade->priv->end_surface != NULL);
#if GTK_CHECK_VERSION (3, 0, 0)
cairo_pattern_t *pattern;
pattern = cairo_pattern_create_for_surface (fade->priv->end_surface);
gdk_window_set_background_pattern (fade->priv->window, pattern);
cairo_pattern_destroy (pattern);
#else
gdk_window_set_back_pixmap (fade->priv->window,
fade->priv->end_surface,
FALSE);
#endif
draw_background (fade);
cairo_surface_destroy (fade->priv->end_surface);
fade->priv->end_surface = NULL;
g_assert (fade->priv->fading_surface != NULL);
cairo_surface_destroy (fade->priv->fading_surface);
fade->priv->fading_surface = NULL;
fade->priv->timeout_id = 0;
g_signal_emit (fade, signals[FINISHED], 0, fade->priv->window);
}
/**
* go_combo_tearoff_bg_copy
* @combo_box: Combo box
*
* Copy popup window image to the tearoff window.
*/
static void
go_combo_tearoff_bg_copy (GOComboBox *combo)
{
GdkPixmap *pixmap;
GdkGC *gc;
GdkGCValues gc_values;
GtkWidget *widget = combo->priv->popup;
if (combo->priv->torn_off) {
gc_values.subwindow_mode = GDK_INCLUDE_INFERIORS;
gc = gdk_gc_new_with_values (widget->window,
&gc_values, GDK_GC_SUBWINDOW);
pixmap = gdk_pixmap_new (widget->window,
widget->allocation.width,
widget->allocation.height,
-1);
gdk_draw_drawable (pixmap, gc,
widget->window,
0, 0, 0, 0, -1, -1);
g_object_unref (gc);
gtk_widget_set_size_request (combo->priv->tearoff_window,
widget->allocation.width,
widget->allocation.height);
gdk_window_set_back_pixmap
(combo->priv->tearoff_window->window, pixmap, FALSE);
g_object_unref (pixmap);
}
}
static void sanalyzer_playback_start(void)
{
if(window)
{
gdk_window_set_back_pixmap(area->window,draw_pixmap,0);
gdk_window_clear(area->window);
}
}
static void sanalyzer_playback_stop(void)
{
if(GTK_WIDGET_REALIZED(area))
{
gdk_window_set_back_pixmap(area->window,bg_pixmap,0);
gdk_window_clear(area->window);
}
}
static VALUE
gdkwin_set_back_pixmap(VALUE self, VALUE pixmap, VALUE parent_relative)
{
gdk_window_set_back_pixmap(_SELF(self),
GDK_PIXMAP(RVAL2GOBJ(pixmap)),
RVAL2CBOOL(parent_relative));
return self;
}
void show_shape(float_shape_t *shape)
{
gtk_window_move(GTK_WINDOW(shape->window), shape->x, shape->y);
gtk_window_resize(GTK_WINDOW(shape->window), shape->width, shape->height);
gtk_widget_show_all(shape->window);
gdk_window_set_back_pixmap(shape->window->window, NULL, TRUE);
}
void
moz_container_realize (GtkWidget *widget)
{
GdkWindowAttr attributes;
gint attributes_mask = 0;
MozContainer *container;
GtkAllocation allocation;
g_return_if_fail(IS_MOZ_CONTAINER(widget));
container = MOZ_CONTAINER(widget);
gtk_widget_set_realized(widget, TRUE);
/* create the shell window */
attributes.event_mask = (gtk_widget_get_events (widget) |
GDK_EXPOSURE_MASK | GDK_STRUCTURE_MASK |
GDK_VISIBILITY_NOTIFY_MASK |
GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK |
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
#ifdef MOZ_PLATFORM_MAEMO
GDK_POINTER_MOTION_HINT_MASK |
#endif
GDK_POINTER_MOTION_MASK);
gtk_widget_get_allocation(widget, &allocation);
attributes.x = allocation.x;
attributes.y = allocation.y;
attributes.width = allocation.width;
attributes.height = allocation.height;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.visual = gtk_widget_get_visual (widget);
#if defined(MOZ_WIDGET_GTK2)
attributes.colormap = gtk_widget_get_colormap (widget);
#endif
attributes.window_type = GDK_WINDOW_CHILD;
attributes_mask |= GDK_WA_VISUAL | GDK_WA_X | GDK_WA_Y;
#if defined(MOZ_WIDGET_GTK2)
attributes_mask |= GDK_WA_COLORMAP;
#endif
gtk_widget_set_window(widget, gdk_window_new (gtk_widget_get_parent_window (widget),
&attributes, attributes_mask));
/* printf("widget->window is %p\n", (void *)widget->window); */
gdk_window_set_user_data (gtk_widget_get_window(widget), container);
#if defined(MOZ_WIDGET_GTK2)
widget->style = gtk_style_attach (widget->style, widget->window);
#endif
/* TODO GTK3? */
#if defined(MOZ_WIDGET_GTK2)
/* set the back pixmap to None so that you don't end up with the gtk
default which is BlackPixel */
gdk_window_set_back_pixmap (widget->window, NULL, FALSE);
#endif
}
static void
bytes_view_realize(GtkWidget *widget)
{
BytesView *bv;
GdkWindowAttr attributes;
GtkAllocation allocation;
GdkWindow *win;
#if GTK_CHECK_VERSION(3, 0, 0)
GtkStyleContext *context;
#endif
_gtk_widget_set_realized_true(widget);
bv = BYTES_VIEW(widget);
gtk_widget_get_allocation(widget, &allocation);
attributes.window_type = GDK_WINDOW_CHILD;
attributes.x = allocation.x;
attributes.y = allocation.y;
attributes.width = allocation.width;
attributes.height = allocation.height;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.visual = gtk_widget_get_visual(widget);
attributes.event_mask = gtk_widget_get_events(widget) | GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK;
#if !GTK_CHECK_VERSION(3, 0, 0)
attributes.colormap = gtk_widget_get_colormap(widget);
win = gdk_window_new(gtk_widget_get_parent_window(widget), &attributes, GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP);
#else
win = gdk_window_new(gtk_widget_get_parent_window(widget), &attributes, GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL);
#endif
gtk_widget_set_window(widget, win);
#if GTK_CHECK_VERSION(3, 8, 0)
gtk_widget_register_window(widget, win);
#else
gdk_window_set_user_data(win, widget);
#endif
#if !GTK_CHECK_VERSION(3, 0, 0) /* XXX, check */
gdk_window_set_back_pixmap(win, NULL, FALSE);
#endif
#if GTK_CHECK_VERSION(3, 0, 0)
context = gtk_widget_get_style_context(widget);
gtk_style_context_add_class(context, GTK_STYLE_CLASS_VIEW);
/* gtk_style_context_add_class(context, GTK_STYLE_CLASS_ENTRY); */
#elif GTK_CHECK_VERSION(2, 20, 0)
gtk_widget_style_attach(widget);
#else
widget->style = gtk_style_attach(widget->style, win);
#endif
bytes_view_ensure_layout(bv);
}
nsresult nsPluginNativeWindowGtk2::CreateXEmbedWindow() {
NS_ASSERTION(!mSocketWidget,"Already created a socket widget!");
GdkWindow *parent_win = gdk_window_lookup((XID)window);
mSocketWidget = gtk_socket_new();
//attach the socket to the container widget
gtk_widget_set_parent_window(mSocketWidget, parent_win);
// Make sure to handle the plug_removed signal. If we don't the
// socket will automatically be destroyed when the plug is
// removed, which means we're destroying it more than once.
// SYNTAX ERROR.
g_signal_connect(mSocketWidget, "plug_removed",
G_CALLBACK(plug_removed_cb), NULL);
g_signal_connect(mSocketWidget, "unrealize",
G_CALLBACK(socket_unrealize_cb), NULL);
g_signal_connect(mSocketWidget, "destroy",
G_CALLBACK(gtk_widget_destroyed), &mSocketWidget);
gpointer user_data = NULL;
gdk_window_get_user_data(parent_win, &user_data);
GtkContainer *container = GTK_CONTAINER(user_data);
gtk_container_add(container, mSocketWidget);
gtk_widget_realize(mSocketWidget);
// The GtkSocket has a visible window, but the plugin's XEmbed plug will
// cover this window. Normally GtkSockets let the X server paint their
// background and this would happen immediately (before the plug is
// created). Setting the background to None prevents the server from
// painting this window, avoiding flicker.
gdk_window_set_back_pixmap(mSocketWidget->window, NULL, FALSE);
// Resize before we show
SetAllocation();
gtk_widget_show(mSocketWidget);
gdk_flush();
window = (void*)gtk_socket_get_id(GTK_SOCKET(mSocketWidget));
// Fill out the ws_info structure.
// (The windowless case is done in nsObjectFrame.cpp.)
GdkWindow *gdkWindow = gdk_window_lookup((XID)window);
if(!gdkWindow)
return NS_ERROR_FAILURE;
mWsInfo.display = GDK_WINDOW_XDISPLAY(gdkWindow);
mWsInfo.colormap = GDK_COLORMAP_XCOLORMAP(gdk_drawable_get_colormap(gdkWindow));
GdkVisual* gdkVisual = gdk_drawable_get_visual(gdkWindow);
mWsInfo.visual = GDK_VISUAL_XVISUAL(gdkVisual);
mWsInfo.depth = gdkVisual->depth;
return NS_OK;
}
static void
na_tray_manager_make_socket_transparent (GtkWidget *widget,
gpointer user_data)
{
if (GTK_WIDGET_NO_WINDOW (widget))
return;
gdk_window_set_back_pixmap (widget->window, NULL, TRUE);
}
static void
egg_tray_manager_make_socket_transparent (GtkWidget *widget,
gpointer user_data)
{
ENTER;
if (GTK_WIDGET_NO_WINDOW (widget))
RET();
gdk_window_set_back_pixmap (widget->window, NULL, TRUE);
RET();
}
GtkWidget*
gtk_xtbin_new (GdkWindow *parent_window, String * f)
{
GtkXtBin *xtbin;
gpointer user_data;
assert(parent_window != NULL);
xtbin = g_object_new (GTK_TYPE_XTBIN, NULL);
if (!xtbin)
return (GtkWidget*)NULL;
if (f)
fallback = f;
/* Initialize the Xt toolkit */
xtbin->parent_window = parent_window;
xt_client_init(&(xtbin->xtclient),
GDK_VISUAL_XVISUAL(gdk_rgb_get_visual()),
GDK_COLORMAP_XCOLORMAP(gdk_rgb_get_colormap()),
gdk_rgb_get_visual()->depth);
if (!xtbin->xtclient.xtdisplay) {
/* If XtOpenDisplay failed, we can't go any further.
* Bail out.
*/
#ifdef DEBUG_XTBIN
printf("gtk_xtbin_init: XtOpenDisplay() returned NULL.\n");
#endif
g_free (xtbin);
return (GtkWidget *)NULL;
}
/* Launch X event loop */
xt_client_xloop_create();
/* Build the hierachy */
xtbin->xtdisplay = xtbin->xtclient.xtdisplay;
gtk_widget_set_parent_window(GTK_WIDGET(xtbin), parent_window);
gdk_window_get_user_data(xtbin->parent_window, &user_data);
if (user_data)
gtk_container_add(GTK_CONTAINER(user_data), GTK_WIDGET(xtbin));
/* This GtkSocket has a visible window, but the Xt plug will cover this
* window. Normally GtkSockets let the X server paint their background and
* this would happen immediately (before the plug is mapped). Setting the
* background to None prevents the server from painting this window,
* avoiding flicker.
*/
gtk_widget_realize(GTK_WIDGET(xtbin));
gdk_window_set_back_pixmap(GTK_WIDGET(xtbin)->window, NULL, FALSE);
return GTK_WIDGET (xtbin);
}
/*!
\brief lv_configure_event() is the logviewer configure event that gets called
whenever the display is resized or created
\param widget is the pointer to widget receiving event
\param event is the pointer to Config event structure
\param data is unused)
\returns FALSE
*/
G_MODULE_EXPORT gboolean lv_configure_event(GtkWidget *widget, GdkEventConfigure *event, gpointer data)
{
GdkPixmap *pixmap = NULL;
GdkPixmap *pmap = NULL;
GtkAllocation allocation;
GdkWindow *window = gtk_widget_get_window(widget);
gtk_widget_get_allocation(widget,&allocation);
/* Get pointer to backing pixmap ... */
if (!lv_data)
{
lv_data = g_new0(Logview_Data,1);
lv_data->traces = g_hash_table_new(g_str_hash,g_str_equal);
}
pixmap = lv_data->pixmap;
pmap = lv_data->pmap;
if (window)
{
if (pixmap)
g_object_unref(pixmap);
if (pmap)
g_object_unref(pmap);
gint w = allocation.width;
gint h = allocation.height;
pixmap=gdk_pixmap_new(window,
w,h,
gtk_widget_get_visual(widget)->depth);
gdk_draw_rectangle(pixmap,
gtk_widget_get_style(widget)->black_gc,
TRUE, 0,0,
w,h);
pmap=gdk_pixmap_new(window,
w,h,
gtk_widget_get_visual(widget)->depth);
gdk_draw_rectangle(pmap,
gtk_widget_get_style(widget)->black_gc,
TRUE, 0,0,
w,h);
gdk_window_set_back_pixmap(window,pixmap,0);
lv_data->pixmap = pixmap;
lv_data->pmap = pmap;
if ((lv_data->traces) && (g_list_length(lv_data->tlist) > 0))
{
draw_infotext();
trace_update(TRUE);
}
gdk_window_clear(window);
}
return FALSE;
}
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);
}
static void
e_canvas_realize (GtkWidget *widget)
{
ECanvas *ecanvas = E_CANVAS (widget);
if (GTK_WIDGET_CLASS (e_canvas_parent_class)->realize)
(* GTK_WIDGET_CLASS (e_canvas_parent_class)->realize) (widget);
gdk_window_set_back_pixmap (GTK_LAYOUT (widget)->bin_window, NULL, FALSE);
gtk_im_context_set_client_window (ecanvas->im_context, widget->window);
}
static void
gtk_hex_entry_realize (GtkWidget *widget)
{
GtkHexEntry *hex_entry;
GtkRequisition requisition;
GdkWindowAttr attributes;
gint attributes_mask;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_HEX_ENTRY (widget));
GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
hex_entry = GTK_HEX_ENTRY (widget);
gtk_widget_get_child_requisition (widget, &requisition);
attributes.x = widget->allocation.x;
attributes.y = widget->allocation.y;
attributes.width = requisition.width;
attributes.height = requisition.height;
attributes.window_type = GDK_WINDOW_CHILD;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.visual = gtk_widget_get_visual (widget);
attributes.colormap = gtk_widget_get_colormap (widget);
attributes.cursor = hex_entry->cursor = gdk_cursor_new (GDK_XTERM);
attributes.event_mask = gtk_widget_get_events (widget)
| GDK_EXPOSURE_MASK | GDK_KEY_PRESS_MASK
| GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK
| GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_BUTTON1_MOTION_MASK
| GDK_POINTER_MOTION_HINT_MASK;
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP |
GDK_WA_CURSOR;
widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
&attributes, attributes_mask);
gdk_window_set_user_data (widget->window, hex_entry);
widget->style = gtk_style_attach (widget->style, widget->window);
gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
gdk_window_set_background (widget->window, &widget->style->base[GTK_WIDGET_STATE (widget)]);
gdk_window_set_back_pixmap (widget->window, NULL, TRUE);
gdk_color_alloc (gtk_widget_get_colormap (widget),&hex_entry->cursor_color);
hex_entry->gc = gdk_gc_new (widget->window);
gdk_gc_set_foreground (hex_entry->gc,&hex_entry->cursor_color);
}
