/*!
\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;
}
/*!
\brief handles configure events when the chart gets created or resized.
Takes care of creating/destroying graphics contexts, backing pixmaps (two
levels are used to split the rendering for speed reasons) colormaps are
also created here as well
\param widget (GtkWidget *) pointer to the chart object
\param event (GdkEventConfigure *) pointer to GDK event datastructure that
encodes important info like window dimensions and depth.
*/
gboolean mtx_stripchart_configure (GtkWidget *widget, GdkEventConfigure *event)
{
MtxStripChart * chart = MTX_STRIPCHART(widget);
MtxStripChartPrivate *priv = MTX_STRIPCHART_GET_PRIVATE(chart);
cairo_t *cr = NULL;
priv->w = widget->allocation.width;
priv->h = widget->allocation.height;
/* Backing pixmap (copy of window) */
if (priv->bg_pixmap)
g_object_unref(priv->bg_pixmap);
priv->bg_pixmap=gdk_pixmap_new(widget->window,
priv->w,priv->h,
gtk_widget_get_visual(widget)->depth);
cr = gdk_cairo_create(priv->bg_pixmap);
cairo_set_operator(cr,CAIRO_OPERATOR_DEST_OUT);
cairo_paint(cr);
cairo_destroy(cr);
/* Trace pixmap */
if (priv->trace_pixmap)
g_object_unref(priv->trace_pixmap);
priv->trace_pixmap=gdk_pixmap_new(widget->window,
priv->w,priv->h,
gtk_widget_get_visual(widget)->depth);
cr = gdk_cairo_create(priv->trace_pixmap);
cairo_set_operator(cr,CAIRO_OPERATOR_DEST_OUT);
cairo_paint(cr);
cairo_destroy(cr);
/* Grat pixmap */
if (priv->grat_pixmap)
g_object_unref(priv->grat_pixmap);
priv->grat_pixmap=gdk_pixmap_new(widget->window,
priv->w,priv->h,
gtk_widget_get_visual(widget)->depth);
cr = gdk_cairo_create(priv->grat_pixmap);
cairo_set_operator(cr,CAIRO_OPERATOR_DEST_OUT);
cairo_paint(cr);
cairo_destroy(cr);
gdk_window_set_back_pixmap(widget->window,priv->bg_pixmap,0);
if (priv->font_options)
cairo_font_options_destroy(priv->font_options);
priv->font_options = cairo_font_options_create();
cairo_font_options_set_antialias(priv->font_options,
CAIRO_ANTIALIAS_GRAY);
generate_stripchart_static_traces(chart);
render_marker (chart);
return TRUE;
}
void gtk_codegraph_realize(GtkWidget *widget){
GdkWindowAttr attributes;
guint attributes_mask;
g_return_if_fail(widget != NULL);
g_return_if_fail(GTK_IS_CODEGRAPH(widget));
GTK_WIDGET_SET_FLAGS(widget, GTK_REALIZED);
attributes.window_type = GDK_WINDOW_CHILD;
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.visual = gtk_widget_get_visual (widget);
attributes.colormap = gtk_widget_get_colormap (widget);
attributes.event_mask = gtk_widget_get_events (widget);
attributes.event_mask |= (GDK_EXPOSURE_MASK |
GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK);
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
widget->window = gdk_window_new(
gtk_widget_get_parent_window (widget),
& attributes, attributes_mask);
gdk_window_set_user_data(widget->window, widget );
widget->style = gtk_style_attach(widget->style, widget->window);
gtk_style_set_background(widget->style, widget->window, GTK_STATE_NORMAL);
gtk_codegraph_create_backing_pixmap(GTK_CODEGRAPH(widget));
}
static void
pp_layout_nup_pageview_realize (GtkWidget *widget)
{
pp_Layout_NUp_PageView *pageview;
GdkWindowAttr attributes;
gint attributes_mask;
g_return_if_fail (widget != NULL);
g_return_if_fail (PP_IS_PAGEVIEW (widget));
GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
pageview = PP_LAYOUT_NUP_PAGEVIEW (widget);
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 | GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK;
attributes.visual = gtk_widget_get_visual (widget);
attributes.colormap = gtk_widget_get_colormap (widget);
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
widget->window = gdk_window_new (widget->parent->window, &attributes, attributes_mask);
widget->style = gtk_style_attach (widget->style, widget->window);
gdk_window_set_user_data (widget->window, widget);
gtk_style_set_background (widget->style, widget->window, GTK_STATE_ACTIVE);
}
/* Does not require locking: meant to be called after the drawing
surface is locked. */
int
classpath_jawt_get_depth (JNIEnv* env, jobject canvas)
{
GtkWidget *widget;
GdkVisual *visual;
void *ptr;
jobject peer;
jclass class_id;
jmethodID method_id;
class_id = (*env)->GetObjectClass (env, canvas);
method_id = (*env)->GetMethodID (env, class_id,
"getPeer",
"()Ljava/awt/peer/ComponentPeer;");
peer = (*env)->CallObjectMethod (env, canvas, method_id);
ptr = gtkpeer_get_widget (env, peer);
widget = GTK_WIDGET (ptr);
if (GTK_WIDGET_REALIZED (widget))
{
visual = gtk_widget_get_visual (widget);
g_assert (visual != NULL);
return visual->depth;
}
else
return (VisualID) NULL;
}
/** gul_gui_window_present:
* @window: A #GtkWindow
* @user_time: Time of the event that caused the window to
* want to raise
*
* Like gtk_window_present, but doesn't have
* http://bugzilla.gnome.org/show_bug.cgi?id=166379
**/
void
gul_gui_window_present (GtkWindow *window, guint32 user_time)
{
GtkWidget *widget;
g_return_if_fail (GTK_IS_WINDOW (window));
widget = GTK_WIDGET (window);
if (gtk_widget_get_visual (widget))
{
g_assert (widget->window != NULL);
if (user_time == 0)
{
user_time = gtk_get_current_event_time ();
}
gdk_window_show (widget->window);
/* note that gdk_window_focus() will also move the window to
* the current desktop, for WM spec compliant window managers.
*/
gdk_window_focus (widget->window, user_time);
}
else
{
gtk_widget_show (widget);
}
}
std::unique_ptr<BackingStoreBackendCairo> BackingStore::createBackend()
{
#if PLATFORM(GTK) && PLATFORM(X11)
const auto& sharedDisplay = PlatformDisplay::sharedDisplay();
if (is<PlatformDisplayX11>(sharedDisplay)) {
GdkVisual* visual = gtk_widget_get_visual(m_webPageProxy.viewWidget());
GdkScreen* screen = gdk_visual_get_screen(visual);
ASSERT(downcast<PlatformDisplayX11>(sharedDisplay).native() == GDK_SCREEN_XDISPLAY(screen));
return std::make_unique<BackingStoreBackendCairoX11>(downcast<PlatformDisplayX11>(sharedDisplay).native(), GDK_WINDOW_XID(gdk_screen_get_root_window(screen)),
GDK_VISUAL_XVISUAL(visual), gdk_visual_get_depth(visual), m_size, m_deviceScaleFactor);
}
#endif
IntSize scaledSize = m_size;
scaledSize.scale(m_deviceScaleFactor);
#if PLATFORM(GTK)
RefPtr<cairo_surface_t> surface = adoptRef(gdk_window_create_similar_surface(gtk_widget_get_window(m_webPageProxy.viewWidget()),
CAIRO_CONTENT_COLOR_ALPHA, scaledSize.width(), scaledSize.height()));
#else
RefPtr<cairo_surface_t> surface = adoptRef(cairo_image_surface_create(CAIRO_FORMAT_ARGB32, scaledSize.width(), scaledSize.height()));
#endif
cairoSurfaceSetDeviceScale(surface.get(), m_deviceScaleFactor, m_deviceScaleFactor);
return std::make_unique<BackingStoreBackendCairoImpl>(surface.get(), m_size);
}
/** Load/construct the images */
static void load_pixmaps(QuoteView * qv)
{
static gboolean init = FALSE;
int width, height;
GdkPixmap *pixmap;
GdkGC *gc;
if (init)
return;
gtk_icon_size_lookup(GTK_ICON_SIZE_MENU, &width, &height);
pixmap =
gdk_pixmap_new(qv->quotes->window, width, height,
gtk_widget_get_visual(qv->quotes)->depth);
gc = gdk_gc_new(pixmap);
gdk_gc_set_fill(gc, GDK_TILED);
gdk_gc_set_tile(gc, theme_get_terrain_pixmap(SEA_TERRAIN));
gdk_gc_set_foreground(gc, &black);
gdk_draw_rectangle(pixmap, gc, TRUE, 0, 0, width, height);
maritime_pixbuf =
gdk_pixbuf_get_from_drawable(NULL, pixmap, NULL, 0, 0, 0, 0,
-1, -1);
g_object_unref(pixmap);
g_object_unref(gc);
cross_pixbuf =
gtk_widget_render_icon(qv->quotes, GTK_STOCK_CANCEL,
GTK_ICON_SIZE_MENU, NULL);
init = TRUE;
}
static void
gtk_experiment_transcript_realize(GtkWidget *widget)
{
GdkWindowAttr attributes;
gint attributes_mask;
gtk_widget_set_realized(widget, TRUE);
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 | GDK_BUTTON_PRESS_MASK;
attributes.visual = gtk_widget_get_visual(widget);
attributes.colormap = gtk_widget_get_colormap(widget);
gtk_widget_set_has_window(widget, TRUE);
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
widget->window = gdk_window_new(gtk_widget_get_parent_window(widget),
&attributes, attributes_mask);
widget->style = gtk_style_attach(widget->style, widget->window);
gdk_window_set_user_data(widget->window, widget);
gtk_style_set_background(widget->style, widget->window, GTK_STATE_ACTIVE);
gtk_experiment_transcript_reconfigure(GTK_EXPERIMENT_TRANSCRIPT(widget));
}
static void
git_source_view_realize (GtkWidget *widget)
{
GdkWindowAttr attribs;
GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
memset (&attribs, 0, sizeof (attribs));
attribs.x = widget->allocation.x;
attribs.y = widget->allocation.y;
attribs.width = widget->allocation.width;
attribs.height = widget->allocation.height;
attribs.wclass = GDK_INPUT_OUTPUT;
attribs.window_type = GDK_WINDOW_CHILD;
attribs.visual = gtk_widget_get_visual (widget);
attribs.colormap = gtk_widget_get_colormap (widget);
attribs.event_mask = gtk_widget_get_events (widget)
| GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK
| GDK_LEAVE_NOTIFY_MASK | GDK_ENTER_NOTIFY_MASK
| GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK;
widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
&attribs,
GDK_WA_X | GDK_WA_Y
| GDK_WA_VISUAL | GDK_WA_COLORMAP);
gdk_window_set_user_data (widget->window, widget);
widget->style = gtk_style_attach (widget->style, widget->window);
gdk_window_set_background (widget->window,
&widget->style->base[GTK_WIDGET_STATE (widget)]);
git_source_view_calculate_line_height (GIT_SOURCE_VIEW (widget));
}
static void
hildon_color_chooser_realize (GtkWidget *widget)
{
HildonColorChooserPrivate *priv = HILDON_COLOR_CHOOSER_GET_PRIVATE (widget);
g_assert (priv);
GdkWindowAttr attributes;
gint attributes_mask;
attributes.x = widget->allocation.x;
attributes.y = widget->allocation.y;
attributes.width = widget->allocation.width;
attributes.height = widget->allocation.height;
attributes.wclass = GDK_INPUT_ONLY;
attributes.window_type = GDK_WINDOW_CHILD;
attributes.event_mask = gtk_widget_get_events (widget) |
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK |
GDK_BUTTON_MOTION_MASK |
GDK_BUTTON1_MOTION_MASK;
attributes.visual = gtk_widget_get_visual (widget);
attributes.colormap = gtk_widget_get_colormap (widget);
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_WMCLASS;
priv->event_window = gdk_window_new (widget->parent->window, &attributes, attributes_mask);
gdk_window_set_user_data (priv->event_window, widget);
GTK_WIDGET_CLASS (parent_class)->realize (widget);
}
static void
moz_web_view_realize(GtkWidget *widget)
{
g_return_if_fail(widget != NULL);
g_return_if_fail(MOZ_IS_WEB_VIEW(widget));
MozWebView *view = MOZ_WEB_VIEW(widget);
GTK_WIDGET_SET_FLAGS(widget, GTK_REALIZED);
GdkWindowAttr attributes;
gint attributes_mask;
attributes.window_type = GDK_WINDOW_CHILD;
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.visual = gtk_widget_get_visual(widget);
attributes.colormap = gtk_widget_get_colormap(widget);
attributes.event_mask = gtk_widget_get_events(widget) | GDK_EXPOSURE_MASK;
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
widget->window = gdk_window_new(gtk_widget_get_parent_window(widget),
&attributes, attributes_mask);
gdk_window_set_user_data(widget->window, view);
gtk_style_set_background(widget->style, widget->window, GTK_STATE_NORMAL);
widget->style = gtk_style_attach (widget->style, widget->window);
}
static void
polygon_view_realize (GtkWidget *widget)
{
GdkWindowAttr attributes;
GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
attributes.window_type = GDK_WINDOW_CHILD;
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.visual = gtk_widget_get_visual (widget);
attributes.colormap = gtk_widget_get_colormap (widget);
attributes.event_mask = gtk_widget_get_events (widget) |
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_KEY_PRESS_MASK |
GDK_KEY_RELEASE_MASK |
GDK_POINTER_MOTION_MASK |
GDK_BUTTON_MOTION_MASK |
GDK_EXPOSURE_MASK;
widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
&attributes,
GDK_WA_X | GDK_WA_Y |
GDK_WA_VISUAL | GDK_WA_COLORMAP);
gdk_window_set_user_data (widget->window, widget);
widget->style = gtk_style_attach (widget->style, widget->window);
gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
}
static void
gstyle_color_widget_realize (GtkWidget *widget)
{
GtkAllocation allocation;
GdkWindow *window;
GdkWindowAttr attributes = {0};
g_assert (GTK_IS_WIDGET (widget));
gtk_widget_get_allocation (widget, &allocation);
gtk_widget_set_realized (widget, TRUE);
attributes.x = allocation.x;
attributes.y = allocation.y;
attributes.width = allocation.width;
attributes.height = allocation.height;
attributes.window_type = GDK_WINDOW_CHILD;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.visual = gtk_widget_get_visual (widget);
attributes.event_mask = gtk_widget_get_events (widget)
| GDK_BUTTON_MOTION_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_POINTER_MOTION_MASK
| GDK_ENTER_NOTIFY_MASK
| GDK_LEAVE_NOTIFY_MASK;
window = gdk_window_new (gtk_widget_get_parent_window (widget),
&attributes, GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL);
gtk_widget_set_window (widget, g_object_ref (window));
gtk_widget_register_window (widget, window);
gdk_window_show (window);
}
/* Called when the widget is realized. This usually happens when you call
* gtk_widget_show() on the widget. */
static void lcd_realize (GtkWidget *widget)
{
Lcd *lcd;
GdkWindowAttr attributes;
gint attr_mask;
g_return_if_fail (widget != NULL);
g_return_if_fail (IS_LCD (widget));
/* Set the GTK_REALIZED flag so it is marked as realized. */
GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
lcd = LCD (widget);
/* Create a new GtkWindowAttr object that will hold info about the GdkWindow. */
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);
attributes.event_mask |= (GDK_EXPOSURE_MASK);
attributes.visual = gtk_widget_get_visual (widget);
attributes.colormap = gtk_widget_get_colormap (widget);
/* Create a new GdkWindow for the widget. */
attr_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
widget->window = gdk_window_new (widget->parent->window, &attributes, attr_mask);
gdk_window_set_user_data (widget->window, lcd);
/* Attach a style to the GdkWindow and draw a background color. */
widget->style = gtk_style_attach (widget->style, widget->window);
gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
gdk_window_show (widget->window);
}
VisualID
classpath_jawt_get_visualID (JNIEnv* env, jobject canvas)
{
GtkWidget *widget;
Visual *visual;
void *ptr;
jobject peer;
jclass class_id;
jmethodID method_id;
class_id = (*env)->GetObjectClass (env, canvas);
method_id = (*env)->GetMethodID (env, class_id,
"getPeer",
"()Ljava/awt/peer/ComponentPeer;");
peer = (*env)->CallObjectMethod (env, canvas, method_id);
ptr = NSA_GET_PTR (env, peer);
gdk_threads_enter ();
widget = GTK_WIDGET (ptr);
g_assert (GTK_WIDGET_REALIZED (widget));
visual = gdk_x11_visual_get_xvisual (gtk_widget_get_visual (widget));
g_assert (visual != NULL);
gdk_threads_leave ();
return visual->visualid;
}
static GdkWindow *
gb_slider_create_child_window (GbSlider *self,
GbSliderChild *child)
{
GtkWidget *widget = (GtkWidget *)self;
GdkWindow *window;
GtkAllocation allocation;
GdkWindowAttr attributes;
gint attributes_mask;
g_assert (GB_IS_SLIDER (self));
g_assert (child != NULL);
gb_slider_compute_child_allocation (self, child, &allocation, NULL);
attributes.window_type = GDK_WINDOW_CHILD;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.width = allocation.width;
attributes.height = allocation.height;
attributes.x = allocation.x;
attributes.y = allocation.y;
attributes.visual = gtk_widget_get_visual (widget);
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
attributes.event_mask = gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK;
window = gdk_window_new (gtk_widget_get_window (widget), &attributes, attributes_mask);
gtk_widget_register_window (widget, window);
gtk_widget_set_parent_window (child->widget, window);
return window;
}
static gboolean
parent_set_hook(GSignalInvocationHint*, guint, const GValue* param_values, void* data)
{
wxGLCanvas* win = (wxGLCanvas*)data;
if (g_value_peek_pointer(¶m_values[0]) == win->m_wxwindow)
{
const XVisualInfo* xvi = (XVisualInfo*)win->m_vi;
GdkVisual* visual = gtk_widget_get_visual(win->m_wxwindow);
if (GDK_VISUAL_XVISUAL(visual)->visualid != xvi->visualid)
{
#if GTK_CHECK_VERSION(2, 2, 0)
if (gtk_check_version(2, 2, 0) == NULL)
{
GdkScreen* screen = gtk_widget_get_screen(win->m_wxwindow);
visual = gdk_x11_screen_lookup_visual(screen, xvi->visualid);
}
else
#endif
{
visual = gdkx_visual_get(xvi->visualid);
}
GdkColormap* colormap = gdk_colormap_new(visual, false);
gtk_widget_set_colormap(win->m_wxwindow, colormap);
g_object_unref(colormap);
}
// remove hook
return false;
}
return true;
}
static GdkWindow *
gstyle_slidein_create_child_window (GstyleSlidein *self)
{
GtkWidget *widget = GTK_WIDGET (self);
GtkAllocation parent_alloc;
GtkAllocation child_alloc;
GdkWindow *window;
GdkWindowAttr attributes;
gint attributes_mask;
gtk_widget_get_allocation (GTK_WIDGET (self), &parent_alloc);
gstyle_slidein_compute_child_allocation (self, parent_alloc, &child_alloc);
attributes.window_type = GDK_WINDOW_CHILD;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.width = child_alloc.width;
attributes.height = child_alloc.height;
attributes.x = child_alloc.x;
attributes.y = child_alloc.y;
attributes.visual = gtk_widget_get_visual (widget);
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
attributes.event_mask = gtk_widget_get_events (widget);
window = gdk_window_new (gtk_widget_get_window (widget), &attributes, attributes_mask);
gtk_widget_register_window (widget, window);
gtk_widget_set_parent_window (self->overlay_child, window);
return window;
}
static void
cvImageWidget_realize (GtkWidget *widget)
{
CvImageWidget *image_widget;
GdkWindowAttr attributes;
gint attributes_mask;
//printf("cvImageWidget_realize\n");
g_return_if_fail (widget != NULL);
g_return_if_fail (CV_IS_IMAGE_WIDGET (widget));
GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
image_widget = CV_IMAGE_WIDGET (widget);
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 | GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK;
attributes.visual = gtk_widget_get_visual (widget);
attributes.colormap = gtk_widget_get_colormap (widget);
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
widget->window = gdk_window_new (widget->parent->window, &attributes, attributes_mask);
widget->style = gtk_style_attach (widget->style, widget->window);
gdk_window_set_user_data (widget->window, widget);
gtk_style_set_background (widget->style, widget->window, GTK_STATE_ACTIVE);
}
static void scope_realize(GtkWidget *widget)
{
Scope *scope;
GdkWindowAttr attributes;
gint attributes_mask;
GdkGCValues gc_values;
GtkAllocation allocation;
GdkWindow *window;
GtkStyle *style;
g_return_if_fail(widget != NULL);
g_return_if_fail(IS_SCOPE(widget));
scope = SCOPE(widget);
gtk_widget_set_realized(widget, TRUE);
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.colormap = gtk_widget_get_colormap(widget);
attributes.event_mask = gtk_widget_get_events(widget) | GDK_EXPOSURE_MASK;
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
gtk_widget_set_has_window(widget, TRUE);
window = gdk_window_new(gtk_widget_get_parent_window(widget), &attributes, attributes_mask);
gtk_widget_set_window(widget, window);
gdk_window_set_user_data(window, scope);
gtk_widget_style_attach(widget);
style = gtk_widget_get_style(widget);
gtk_style_set_background(style, window, GTK_STATE_NORMAL);
/* gc's if necessary */
if (!gdk_colormap_alloc_color(style->colormap, &scope->tracecol,
FALSE, TRUE))
g_warning("unable to allocate color: ( %d %d %d )",
scope->tracecol.red, scope->tracecol.green, scope->tracecol.blue);
gc_values.foreground = scope->tracecol;
scope->trace_gc = gtk_gc_get(style->depth,
style->colormap,
&gc_values, GDK_GC_FOREGROUND);
if (!gdk_colormap_alloc_color(style->colormap, &scope->gridcol,
FALSE, TRUE))
g_warning("unable to allocate color: ( %d %d %d )",
scope->gridcol.red, scope->gridcol.green, scope->gridcol.blue);
gc_values.foreground = scope->gridcol;
scope->grid_gc = gtk_gc_get(style->depth,
style->colormap,
&gc_values, GDK_GC_FOREGROUND);
/* create backing store */
scope->pixmap = gdk_pixmap_new(window, SCOPE_WIDTH, SCOPE_HEIGHT, -1);
scope_send_configure(SCOPE(widget));
}
static gboolean
parent_set_hook(GSignalInvocationHint*, guint, const GValue* param_values, void* data)
{
wxGLCanvas* win = (wxGLCanvas*)data;
if (g_value_peek_pointer(¶m_values[0]) == win->m_wxwindow)
{
const XVisualInfo* xvi = win->GetXVisualInfo();
GdkVisual* visual = gtk_widget_get_visual(win->m_wxwindow);
if (GDK_VISUAL_XVISUAL(visual)->visualid != xvi->visualid)
{
GdkScreen* screen = gtk_widget_get_screen(win->m_wxwindow);
visual = gdk_x11_screen_lookup_visual(screen, xvi->visualid);
#ifdef __WXGTK3__
gtk_widget_set_visual(win->m_wxwindow, visual);
#else
GdkColormap* colormap = gdk_colormap_new(visual, false);
gtk_widget_set_colormap(win->m_wxwindow, colormap);
g_object_unref(colormap);
#endif
}
// remove hook
return false;
}
return true;
}
static void
gtk_revealer_real_realize (GtkWidget *widget)
{
GtkRevealer *revealer = GTK_REVEALER (widget);
GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer);
GtkAllocation allocation;
GdkWindowAttr attributes = { 0 };
GdkWindowAttributesType attributes_mask;
GtkAllocation child_allocation;
GtkWidget *child;
GtkStyleContext *context;
GtkRevealerTransitionType transition;
gtk_widget_set_realized (widget, TRUE);
gtk_widget_get_allocation (widget, &allocation);
attributes.x = allocation.x;
attributes.y = allocation.y;
attributes.width = allocation.width;
attributes.height = allocation.height;
attributes.window_type = GDK_WINDOW_CHILD;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.visual = gtk_widget_get_visual (widget);
attributes.event_mask =
gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK;
attributes_mask = (GDK_WA_X | GDK_WA_Y) | GDK_WA_VISUAL;
priv->view_window =
gdk_window_new (gtk_widget_get_parent_window ((GtkWidget*) revealer),
&attributes, attributes_mask);
gtk_widget_set_window (widget, priv->view_window);
gtk_widget_register_window (widget, priv->view_window);
gtk_revealer_get_child_allocation (revealer, &allocation, &child_allocation);
attributes.x = 0;
attributes.y = 0;
attributes.width = child_allocation.width;
attributes.height = child_allocation.height;
transition = effective_transition (revealer);
if (transition == GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN)
attributes.y = allocation.height - child_allocation.height;
else if (transition == GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT)
attributes.x = allocation.width - child_allocation.width;
priv->bin_window =
gdk_window_new (priv->view_window, &attributes, attributes_mask);
gtk_widget_register_window (widget, priv->bin_window);
child = gtk_bin_get_child (GTK_BIN (revealer));
if (child != NULL)
gtk_widget_set_parent_window (child, priv->bin_window);
context = gtk_widget_get_style_context (widget);
gtk_style_context_set_background (context, priv->view_window);
gtk_style_context_set_background (context, priv->bin_window);
gdk_window_show (priv->bin_window);
}
static void
uni_image_view_realize (GtkWidget * widget)
{
UniImageView *view = UNI_IMAGE_VIEW (widget);
gtk_widget_set_realized(widget, TRUE);
GdkWindowAttr attrs;
attrs.window_type = GDK_WINDOW_CHILD;
attrs.x = widget->allocation.x;
attrs.y = widget->allocation.y;
attrs.width = widget->allocation.width;
attrs.height = widget->allocation.height;
attrs.wclass = GDK_INPUT_OUTPUT;
attrs.visual = gtk_widget_get_visual (widget);
attrs.colormap = gtk_widget_get_colormap (widget);
attrs.event_mask = (gtk_widget_get_events (widget)
| GDK_EXPOSURE_MASK
| GDK_BUTTON_MOTION_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK);
int attr_mask = (GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP);
GdkWindow *parent = gtk_widget_get_parent_window (widget);
widget->window = gdk_window_new (parent, &attrs, attr_mask);
gdk_window_set_user_data (widget->window, view);
widget->style = gtk_style_attach (widget->style, widget->window);
gtk_style_set_background (widget->style, widget->window,
GTK_STATE_NORMAL);
view->void_cursor = gdk_cursor_new (GDK_ARROW);
}
static void
pnl_dock_revealer_realize (GtkWidget *widget)
{
PnlDockRevealer *self = (PnlDockRevealer *)widget;
PnlDockRevealerPrivate *priv = pnl_dock_revealer_get_instance_private (self);
GdkWindowAttr attributes = { 0 };
GdkWindow *parent;
GtkAllocation alloc;
gint attributes_mask = 0;
g_assert (PNL_IS_DOCK_REVEALER (widget));
gtk_widget_get_allocation (GTK_WIDGET (self), &alloc);
gtk_widget_set_realized (GTK_WIDGET (self), TRUE);
parent = gtk_widget_get_parent_window (GTK_WIDGET (self));
attributes.window_type = GDK_WINDOW_CHILD;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.visual = gtk_widget_get_visual (GTK_WIDGET (self));
attributes.x = alloc.x;
attributes.y = alloc.y;
attributes.width = alloc.width;
attributes.height = alloc.height;
attributes.event_mask = 0;
attributes_mask = (GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL);
priv->window = gdk_window_new (parent, &attributes, attributes_mask);
gtk_widget_set_window (GTK_WIDGET (self), priv->window);
gtk_widget_register_window (GTK_WIDGET (self), priv->window);
}
static void rc_ui_scrollable_label_realize(GtkWidget *widget)
{
RCUiScrollableLabel *label;
GdkWindowAttr attributes;
GtkAllocation allocation;
GdkWindow *window, *parent;
gint attr_mask;
GtkStyleContext *context;
g_return_if_fail(widget!=NULL);
g_return_if_fail(RC_UI_IS_SCROLLABLE_LABEL(widget));
label = RC_UI_SCROLLABLE_LABEL(widget);
gtk_widget_set_realized(widget, TRUE);
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.window_type = GDK_WINDOW_CHILD;
attributes.event_mask = gtk_widget_get_events(widget);
attributes.event_mask |= (GDK_EXPOSURE_MASK);
attributes.visual = gtk_widget_get_visual(widget);
attr_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
gtk_widget_set_has_window(widget, TRUE);
parent = gtk_widget_get_parent_window(widget);
window = gdk_window_new(parent, &attributes, attr_mask);
gtk_widget_set_window(widget, window);
gdk_window_set_user_data(window, label);
gdk_window_set_background_pattern(window, NULL);
context = gtk_widget_get_style_context(widget);
gtk_style_context_set_background(context, window);
gdk_window_show(window);
}
static void
hand_display_realize (GtkWidget *widget)
{
GdkWindowAttr attributes;
gint attributes_mask;
g_return_if_fail (widget != NULL);
g_return_if_fail (IS_HAND_DISPLAY (widget));
gtk_widget_set_realized (widget, TRUE);
GtkAllocation allocation;
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.window_type = GDK_WINDOW_CHILD;
attributes.event_mask = gtk_widget_get_events (widget) |
GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK |
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK;
attributes.visual = gtk_widget_get_visual (widget);
attributes.colormap = gtk_widget_get_colormap (widget);
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
GdkWindow *window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
gtk_widget_set_window (widget, window);
gtk_widget_style_attach (widget);
gdk_window_set_user_data (window, widget);
gtk_style_set_background (gtk_widget_get_style (widget), window, GTK_STATE_ACTIVE);
}
/*!
\brief handles configure events whe nthe gauge gets created or resized.
Takes care of creating/destroying graphics contexts, backing pixmaps (two
levels are used to split the rendering for speed reasons) colormaps are
also created here as well
\param widget (GtkWidget *) pointer to the gauge object
\param event (GdkEventConfigure *) pointer to GDK event datastructure that
encodes important info like window dimensions and depth.
*/
gboolean mtx_pie_gauge_configure (GtkWidget *widget, GdkEventConfigure *event)
{
MtxPieGauge * gauge = MTX_PIE_GAUGE(widget);
MtxPieGaugePrivate *priv = MTX_PIE_GAUGE_GET_PRIVATE(gauge);
priv->w = widget->allocation.width;
priv->h = widget->allocation.height;
if (priv->gc)
g_object_unref(priv->gc);
/* Backing pixmap (copy of window) */
if (priv->pixmap)
g_object_unref(priv->pixmap);
priv->pixmap=gdk_pixmap_new(widget->window,
priv->w,priv->h,
gtk_widget_get_visual(widget)->depth);
gdk_draw_rectangle(priv->pixmap,
widget->style->black_gc,
TRUE, 0,0,
priv->w,priv->h);
/* Static Background pixmap */
if (priv->bg_pixmap)
g_object_unref(priv->bg_pixmap);
priv->bg_pixmap=gdk_pixmap_new(widget->window,
priv->w,priv->h,
gtk_widget_get_visual(widget)->depth);
gdk_draw_rectangle(priv->bg_pixmap,
widget->style->black_gc,
TRUE, 0,0,
priv->w,priv->h);
gdk_window_set_back_pixmap(widget->window,priv->pixmap,0);
priv->gc = gdk_gc_new(priv->bg_pixmap);
gdk_gc_set_colormap(priv->gc,priv->colormap);
if (priv->font_options)
cairo_font_options_destroy(priv->font_options);
priv->font_options = cairo_font_options_create();
cairo_font_options_set_antialias(priv->font_options,
CAIRO_ANTIALIAS_GRAY);
generate_pie_gauge_background(gauge);
update_pie_gauge_position(gauge);
return TRUE;
}
static void browwidgetgtk_realize( GtkWidget *widget)
{
GdkWindowAttr attr;
gint attr_mask;
BrowWidgetGtk *brow;
g_return_if_fail (widget != NULL);
g_return_if_fail (IS_BROWWIDGETGTK( widget));
GTK_WIDGET_SET_FLAGS( widget, GTK_REALIZED);
brow = BROWWIDGETGTK( widget);
attr.x = widget->allocation.x;
attr.y = widget->allocation.y;
attr.width = widget->allocation.width;
attr.height = widget->allocation.height;
attr.wclass = GDK_INPUT_OUTPUT;
attr.window_type = GDK_WINDOW_CHILD;
attr.event_mask = gtk_widget_get_events( widget) |
GDK_EXPOSURE_MASK |
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_KEY_PRESS_MASK |
GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK |
GDK_BUTTON_MOTION_MASK |
GDK_ENTER_NOTIFY_MASK |
GDK_LEAVE_NOTIFY_MASK |
GDK_SCROLL_MASK;
attr.visual = gtk_widget_get_visual( widget);
attr.colormap = gtk_widget_get_colormap( widget);
attr_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
widget->window = gdk_window_new( widget->parent->window, &attr, attr_mask);
widget->style = gtk_style_attach( widget->style, widget->window);
gdk_window_set_user_data( widget->window, widget);
gtk_style_set_background( widget->style, widget->window, GTK_STATE_ACTIVE);
GTK_WIDGET_SET_FLAGS( widget, GTK_CAN_FOCUS);
if ( brow->is_navigator) {
if ( !brow->brow_ctx) {
BrowWidgetGtk *main_brow = (BrowWidgetGtk *) brow->main_brow_widget;
brow->brow_ctx = main_brow->brow_ctx;
brow->draw_ctx = main_brow->draw_ctx;
((FlowDrawGtk *)brow->draw_ctx)->init_nav( widget, brow->brow_ctx);
}
}
else {
if ( !brow->brow_ctx) {
brow->draw_ctx = new FlowDrawGtk( widget,
&brow->brow_ctx,
brow_init_proc,
brow->client_data,
flow_eCtxType_Brow);
}
}
}
static void
ViewOvBoxRealize(GtkWidget *widget) // IN
{
ViewOvBox *that;
ViewOvBoxPrivate *priv;
GdkWindowAttr attributes;
gint mask;
GtkAllocation allocation;
GdkWindow *window;
gtk_widget_set_realized (widget, TRUE);
that = VIEW_OV_BOX(widget);
priv = that->priv;
attributes.window_type = GDK_WINDOW_CHILD;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.visual = gtk_widget_get_visual(widget);
attributes.event_mask = gtk_widget_get_events(widget) | GDK_EXPOSURE_MASK;
mask = GDK_WA_VISUAL | GDK_WA_X | GDK_WA_Y;
gtk_widget_get_allocation(widget, &allocation);
attributes.x = allocation.x;
attributes.y = allocation.y;
attributes.width = allocation.width;
attributes.height = allocation.height;
window = gdk_window_new(gtk_widget_get_parent_window(widget),
&attributes, mask);
gtk_widget_set_window(widget, window);
gdk_window_set_user_data(window, that);
#if !GTK_CHECK_VERSION(3, 0, 0)
gtk_widget_set_style(widget, gtk_style_attach(gtk_widget_get_style(widget), window));
#endif
/*
* The order in which we create the children X window matters: the child
* created last is stacked on top. --hpreg
*/
ViewOvBoxGetUnderGeometry(that, &attributes.x, &attributes.y,
&attributes.width, &attributes.height);
priv->underWin = gdk_window_new(window, &attributes, mask);
gdk_window_set_user_data(priv->underWin, that);
if (priv->under) {
gtk_widget_set_parent_window(priv->under, priv->underWin);
}
gdk_window_show(priv->underWin);
ViewOvBoxGetOverGeometry(that, &attributes.x, &attributes.y,
&attributes.width, &attributes.height);
priv->overWin = gdk_window_new(window, &attributes, mask);
gdk_window_set_user_data(priv->overWin, that);
if (priv->over) {
gtk_widget_set_parent_window(priv->over, priv->overWin);
}
gdk_window_show(priv->overWin);
ViewOvBoxSetBackground(that);
}
