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); }
static void gtk_notification_realize (GtkWidget *widget) { GtkNotification *notification = GTK_NOTIFICATION (widget); GtkNotificationPrivate *priv = notification->priv; GtkBin *bin = GTK_BIN (widget); GtkAllocation allocation; GtkStyleContext *context; GtkWidget *child; GdkWindow *window; GdkWindowAttr attributes; gint attributes_mask; 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 = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK; attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL; 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, notification); attributes.x = 0; attributes.y = attributes.height + priv->animate_y; attributes.event_mask = gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK | GDK_VISIBILITY_NOTIFY_MASK; priv->bin_window = gdk_window_new (window, &attributes, attributes_mask); gdk_window_set_user_data (priv->bin_window, notification); child = gtk_bin_get_child (bin); if (child) gtk_widget_set_parent_window (child, priv->bin_window); gtk_widget_set_parent_window (priv->close_button, priv->bin_window); context = gtk_widget_get_style_context (widget); gtk_style_context_set_background (context, window); gtk_style_context_set_background (context, priv->bin_window); gdk_window_show (priv->bin_window); }
static void gtk_form_attach_child_window(GtkForm *form, GtkFormChild *child) { if (child->window != NULL) return; /* been there, done that */ if (GTK_WIDGET_NO_WINDOW(child->widget)) { GtkWidget *widget; GdkWindowAttr attributes; gint attributes_mask; widget = GTK_WIDGET(form); attributes.window_type = GDK_WINDOW_CHILD; attributes.x = child->x; attributes.y = child->y; attributes.width = child->widget->requisition.width; attributes.height = child->widget->requisition.height; attributes.wclass = GDK_INPUT_OUTPUT; attributes.visual = gtk_widget_get_visual(widget); attributes.colormap = gtk_widget_get_colormap(widget); attributes.event_mask = GDK_EXPOSURE_MASK; attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP; child->window = gdk_window_new(form->bin_window, &attributes, attributes_mask); gdk_window_set_user_data(child->window, widget); gtk_style_set_background(widget->style, child->window, GTK_STATE_NORMAL); gtk_widget_set_parent_window(child->widget, child->window); gtk_form_set_static_gravity(child->window, TRUE); /* * Install signal handlers to map/unmap child->window * alongside with the actual widget. */ gtk_signal_connect(GTK_OBJECT(child->widget), "map", GTK_SIGNAL_FUNC(>k_form_child_map), child); gtk_signal_connect(GTK_OBJECT(child->widget), "unmap", GTK_SIGNAL_FUNC(>k_form_child_unmap), child); } else if (!GTK_WIDGET_REALIZED(child->widget)) { gtk_widget_set_parent_window(child->widget, form->bin_window); } }
void gtk_pizza_put (GtkPizza *pizza, GtkWidget *widget, gint x, gint y, gint width, gint height) { GtkPizzaChild *child_info; g_return_if_fail (pizza != NULL); g_return_if_fail (GTK_IS_PIZZA (pizza)); g_return_if_fail (widget != NULL); child_info = g_new (GtkPizzaChild, 1); child_info->widget = widget; child_info->x = x; child_info->y = y; child_info->width = width; child_info->height = height; pizza->children = g_list_append (pizza->children, child_info); if (GTK_WIDGET_REALIZED (pizza)) gtk_widget_set_parent_window (widget, pizza->bin_window); gtk_widget_set_parent (widget, GTK_WIDGET (pizza)); if (!IS_ONSCREEN (x, y)) GTK_PRIVATE_SET_FLAG (widget, GTK_IS_OFFSCREEN); gtk_widget_set_usize (widget, width, height); }
static void gd_stack_add (GtkContainer *container, GtkWidget *child) { GdStack *stack = GD_STACK (container); GdStackPrivate *priv = stack->priv; GdStackChildInfo *child_info; g_return_if_fail (child != NULL); child_info = g_slice_new (GdStackChildInfo); child_info->widget = child; child_info->name = NULL; child_info->title = NULL; child_info->symbolic_icon_name = NULL; priv->children = g_list_append (priv->children, child_info); gtk_widget_set_parent_window (child, priv->bin_window); gtk_widget_set_parent (child, GTK_WIDGET (stack)); g_signal_connect (child, "notify::visible", G_CALLBACK (stack_child_visibility_notify_cb), stack); gtk_widget_child_notify (child, "position"); if (priv->visible_child == NULL && gtk_widget_get_visible (child)) set_visible_child (stack, child_info); else gtk_widget_set_child_visible (child, FALSE); if (priv->homogeneous || priv->visible_child == child_info) gtk_widget_queue_resize (GTK_WIDGET (stack)); }
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 gb_slider_unrealize (GtkWidget *widget) { GbSlider *self = (GbSlider *)widget; GbSliderPrivate *priv = gb_slider_get_instance_private (self); gsize i; g_assert (GB_IS_SLIDER (self)); for (i = 0; i < priv->children->len; i++) { GbSliderChild *child; child = g_ptr_array_index (priv->children, i); if (child->window != NULL) { gtk_widget_set_parent_window (child->widget, NULL); gtk_widget_unregister_window (widget, child->window); gdk_window_destroy (child->window); child->window = NULL; } } GTK_WIDGET_CLASS (gb_slider_parent_class)->unrealize (widget); }
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; }
nsresult nsPluginNativeWindowGtk2::CreateXEmbedWindow() { if(!mGtkSocket) { GdkWindow *win = gdk_window_lookup((XID)window); mGtkSocket = gtk_socket_new(); //attach the socket to the container widget gtk_widget_set_parent_window(mGtkSocket, 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(mGtkSocket, "plug_removed", G_CALLBACK(plug_removed_cb), NULL); gpointer user_data = NULL; gdk_window_get_user_data(win, &user_data); GtkContainer *container = GTK_CONTAINER(user_data); gtk_container_add(container, mGtkSocket); gtk_widget_realize(mGtkSocket); // Resize before we show SetAllocation(); gtk_widget_show(mGtkSocket); gdk_flush(); window = (nsPluginPort *)gtk_socket_get_id(GTK_SOCKET(mGtkSocket)); } return NS_OK; }
/** * gtk_layout_put: * @layout: a #GtkLayout * @child_widget: child widget * @x: X position of child widget * @y: Y position of child widget * * Adds @child_widget to @layout, at position (@x,@y). * @layout becomes the new parent container of @child_widget. * **/ void gtk_layout_put (GtkLayout *layout, GtkWidget *child_widget, gint x, gint y) { GtkLayoutPrivate *priv; GtkLayoutChild *child; g_return_if_fail (GTK_IS_LAYOUT (layout)); g_return_if_fail (GTK_IS_WIDGET (child_widget)); priv = layout->priv; child = g_new (GtkLayoutChild, 1); child->widget = child_widget; child->x = x; child->y = y; priv->children = g_list_append (priv->children, child); if (gtk_widget_get_realized (GTK_WIDGET (layout))) gtk_widget_set_parent_window (child->widget, priv->bin_window); gtk_widget_set_parent (child_widget, GTK_WIDGET (layout)); }
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 VALUE rg_set_parent_window(VALUE self, VALUE parent_window) { gtk_widget_set_parent_window(_SELF(self), GDK_WINDOW(RVAL2GOBJ(parent_window))); return self; }
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; }
int main(int argc, char **argv) { gtk_init(&argc, &argv); // gdk_window_set_debug_updates(TRUE); toplevel_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); printf("toplevel window is %p\n", toplevel_window); moz_container = moz_container_new(); printf("moz_container is %p\n", moz_container); gtk_signal_connect(GTK_OBJECT(moz_container), "expose_event", GTK_SIGNAL_FUNC(expose_handler), NULL); gtk_signal_connect(GTK_OBJECT(moz_container), "size_allocate", GTK_SIGNAL_FUNC(size_allocate_handler), NULL); gtk_container_add(GTK_CONTAINER(toplevel_window), moz_container); gtk_widget_realize(moz_container); drawingarea1 = moz_drawingarea_new (NULL, MOZ_CONTAINER(moz_container)); moz_drawingarea_set_visibility (drawingarea1, TRUE); moz_drawingarea_move(drawingarea1, 10, 10); button = gtk_button_new_with_label("foo"); scrollbar = gtk_vscrollbar_new(NULL); gtk_widget_set_parent_window(button, drawingarea1->inner_window); gtk_widget_set_parent_window(scrollbar, drawingarea1->inner_window); moz_container_put(MOZ_CONTAINER(moz_container), button, 0, 0); moz_container_put(MOZ_CONTAINER(moz_container), scrollbar, 0, 50); gtk_widget_show(button); gtk_widget_show(scrollbar); gtk_widget_show(toplevel_window); gtk_widget_show(moz_container); gtk_main(); return 0; }
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); }
//! mengambil widget dialog dengan memakai gaya struct static GtkWidget *modifGetDialogWithStruct(GtkWidget* parent , modifStruct_ *modifStruct , const gchar *title ){ GtkWidget *dialog , *content_area; GtkWidget *label [5]; GtkWidget *total; GtkWidget *filePilih; GtkWidget *table; dialog = gtk_dialog_new(); gtk_widget_set_parent_window( dialog,(GdkWindow*) parent ); table = gtk_table_new(5, 2, FALSE); // content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); gchar *titleLabel [] = {"Hari","Jam","Bagian","Total","Pilih File"}; int i; for(i=0;i<5;i++){ label[i] = gtk_label_new( titleLabel[i]); gtk_table_attach(GTK_TABLE(table), label[i], 0, 1, i,i+1, GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 5, 5); } GtkWidget* jamMnt = modCreateJamMnt(NULL, modifStruct); modifStruct->bagian = gtk_combo_box_new_text(); gtk_combo_box_append_text((GtkComboBox*)modifStruct->bagian,"WIB"); gtk_combo_box_append_text((GtkComboBox*)modifStruct->bagian,"WIS"); modifStruct->hari = localGetComboHari(0); // gtk_combo_box_set_active(modifStruct->hari,5); // modifStruct->filePilih = gtk_file_chooser_button_new_with_dialog(dialog_file_open); modifStruct->filePilih = gtk_button_new_with_label("Pilih File"); g_signal_connect(G_OBJECT(modifStruct->filePilih), "clicked",G_CALLBACK(modifChoseFileSig), NULL); // modifStruct->filePilih = gtk_file_chooser_button_new ( "Select a file",GTK_FILE_CHOOSER_ACTION_OPEN); // gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (modifStruct->filePilih),"/etc"); modifStruct->total = gtk_spin_button_new_with_range (1,10,1); gtk_table_attach(GTK_TABLE(table), modifStruct->hari , 1, 3, 0, 1, GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 5, 5); gtk_table_attach(GTK_TABLE(table), jamMnt , 1, 3, 1, 2, GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 5, 5); gtk_table_attach(GTK_TABLE(table), modifStruct->bagian , 1, 3, 2, 3, GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 5, 5); gtk_table_attach(GTK_TABLE(table), modifStruct->total , 1, 3, 3, 4, GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 5, 5); gtk_table_attach(GTK_TABLE(table), modifStruct->filePilih , 1, 3, 4, 5, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_SHRINK, 5, 5); // gtk_spin_button_set_value(modifStruct->total,25.0); gtk_window_set_default_size(GTK_WINDOW(dialog), 300, 200); gtk_container_add (GTK_CONTAINER (content_area), table ); modifAddButton(dialog,GTK_RESPONSE_CANCEL); gtk_window_set_title(GTK_WINDOW(dialog), title); gtk_dialog_set_has_separator( (GtkDialog *)dialog,TRUE); gtk_window_set_modal( GTK_WINDOW( dialog ), TRUE ); gtk_window_set_transient_for( GTK_WINDOW( dialog ),GTK_WINDOW( globalGetParent() ) ); return dialog; }
static void gtk_revealer_real_add (GtkContainer *container, GtkWidget *child) { GtkRevealer *revealer = GTK_REVEALER (container); GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer); g_return_if_fail (child != NULL); gtk_widget_set_parent_window (child, priv->bin_window); gtk_widget_set_child_visible (child, priv->current_pos != 0.0); GTK_CONTAINER_CLASS (gtk_revealer_parent_class)->add (container, child); }
static void gd_stack_realize (GtkWidget *widget) { GdStack *stack = GD_STACK (widget); GdStackPrivate *priv = stack->priv; GtkAllocation allocation; GdkWindowAttr attributes = { 0 }; GdkWindowAttributesType attributes_mask; GdStackChildInfo *info; GList *l; 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*) stack), &attributes, attributes_mask); gtk_widget_set_window (widget, priv->view_window); gtk_widget_register_window (widget, priv->view_window); attributes.x = get_bin_window_x (stack, &allocation); attributes.y = 0; attributes.width = allocation.width; attributes.height = allocation.height; priv->bin_window = gdk_window_new (priv->view_window, &attributes, attributes_mask); gtk_widget_register_window (widget, priv->bin_window); for (l = priv->children; l != NULL; l = l->next) { info = l->data; gtk_widget_set_parent_window (info->widget, priv->bin_window); } gdk_window_show (priv->bin_window); }
static void gd_notification_add (GtkContainer *container, GtkWidget *child) { GtkBin *bin = GTK_BIN (container); GdNotification *notification = GD_NOTIFICATION (bin); GdNotificationPrivate *priv = notification->priv; g_return_if_fail (gtk_bin_get_child (bin) == NULL); gtk_widget_set_parent_window (child, priv->bin_window); GTK_CONTAINER_CLASS (gd_notification_parent_class)->add (container, child); }
void gtk_offscreen_box_add2 (GtkOffscreenBox *offscreen_box, GtkWidget *child) { g_return_if_fail (GTK_IS_OFFSCREEN_BOX (offscreen_box)); g_return_if_fail (GTK_IS_WIDGET (child)); if (offscreen_box->child2 == NULL) { gtk_widget_set_parent_window (child, offscreen_box->offscreen_window2); gtk_widget_set_parent (child, GTK_WIDGET (offscreen_box)); offscreen_box->child2 = child; } }
static void gtk_rotated_bin_add (GtkContainer *container, GtkWidget *widget) { GtkRotatedBin *bin = GTK_ROTATED_BIN (container); if (!bin->child) { gtk_widget_set_parent_window (widget, bin->offscreen_window); gtk_widget_set_parent (widget, GTK_WIDGET (bin)); bin->child = widget; } else g_warning ("GtkRotatedBin cannot have more than one child\n"); }
void moz_container_remove (GtkContainer *container, GtkWidget *child_widget) { MozContainerChild *child; MozContainer *moz_container; GdkWindow* parent_window; g_return_if_fail (IS_MOZ_CONTAINER(container)); g_return_if_fail (GTK_IS_WIDGET(child_widget)); moz_container = MOZ_CONTAINER(container); child = moz_container_get_child (moz_container, child_widget); g_return_if_fail (child); /* gtk_widget_unparent will remove the parent window (as well as the * parent widget), but, in Mozilla's window hierarchy, the parent window * may need to be kept because it may be part of a GdkWindow sub-hierarchy * that is being moved to another MozContainer. * * (In a conventional GtkWidget hierarchy, GdkWindows being reparented * would have their own GtkWidget and that widget would be the one being * reparented. In Mozilla's hierarchy, the parent_window needs to be * retained so that the GdkWindow sub-hierarchy is maintained.) */ parent_window = gtk_widget_get_parent_window(child_widget); if (parent_window) g_object_ref(parent_window); gtk_widget_unparent(child_widget); if (parent_window) { /* The child_widget will always still exist because g_signal_emit, * which invokes this function, holds a reference. * * If parent_window is the container's root window then it will not be * the parent_window if the child_widget is placed in another * container. */ if (parent_window != gtk_widget_get_window(GTK_WIDGET(container))) gtk_widget_set_parent_window(child_widget, parent_window); g_object_unref(parent_window); } moz_container->children = g_list_remove(moz_container->children, child); g_free(child); }
static void gstyle_slidein_unrealize (GtkWidget *widget) { GstyleSlidein *self = (GstyleSlidein *)widget; g_assert (GSTYLE_IS_SLIDEIN (self)); if (self->overlay_child != NULL && self->overlay_window != NULL) { gtk_widget_set_parent_window (self->overlay_child, NULL); gtk_widget_unregister_window (widget, self->overlay_window); gdk_window_destroy (self->overlay_window); self->overlay_window = NULL; } GTK_WIDGET_CLASS (gstyle_slidein_parent_class)->unrealize (widget); }
void MCNativeLayerX11::doAttach() { if (m_socket == NULL) { // Create a new GTK socket to deal with the XEMBED protocol GtkSocket *t_socket; t_socket = GTK_SOCKET(gtk_socket_new()); // Create a new GTK window to hold the socket MCRectangle t_rect; t_rect = m_object->getrect(); m_child_window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_POPUP)); gtk_widget_set_parent_window(GTK_WIDGET(m_child_window), getStackGdkWindow()); gtk_widget_realize(GTK_WIDGET(m_child_window)); gdk_window_reparent(gtk_widget_get_window(GTK_WIDGET(m_child_window)), getStackGdkWindow(), t_rect.x, t_rect.y); // Add the socket to the window gtk_container_add(GTK_CONTAINER(m_child_window), GTK_WIDGET(t_socket)); // The socket needs to be realised before going any further or any // operations on it will fail. gtk_widget_realize(GTK_WIDGET(t_socket)); // Show the socket (we'll control visibility at the window level) gtk_widget_show(GTK_WIDGET(t_socket)); // Create an empty region to act as an input mask while in edit mode m_input_shape = gdk_region_new(); // Retain a reference to the socket m_socket = GTK_SOCKET(g_object_ref(G_OBJECT(t_socket))); } // Attach the X11 window to this socket if (gtk_socket_get_plug_window(m_socket) == NULL) gtk_socket_add_id(m_socket, m_widget_xid); //fprintf(stderr, "XID: %u\n", gtk_socket_get_id(m_socket)); // Act as if there were a re-layer to put the widget in the right place doRelayer(); doSetViewportGeometry(m_viewport_rect); doSetGeometry(m_rect); doSetVisible(ShouldShowLayer()); }
static void toplevel_delete_event (GtkWidget *toplevel, GdkEvent *event, gpointer none) { GdkWindow *gdk_win; GtkWidget *label = create_tab_label (toplevel); gdk_win = gtk_widget_get_window (notebook); g_assert (gdk_win); gtk_widget_hide (toplevel); gtk_widget_unrealize (toplevel); gtk_widget_set_parent_window (toplevel, gdk_win); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), toplevel, label); gtk_widget_show (toplevel); }
static void goo_canvas_widget_set_canvas (GooCanvasItem *item, GooCanvas *canvas) { GooCanvasItemSimple *simple = (GooCanvasItemSimple*) item; GooCanvasWidget *witem = (GooCanvasWidget*) item; if (simple->canvas != canvas) { if (simple->canvas) goo_canvas_unregister_widget_item (simple->canvas, witem); simple->canvas = canvas; if (simple->canvas) { goo_canvas_register_widget_item (simple->canvas, witem); if (witem->widget) { #if GTK_CHECK_VERSION(2, 19, 0) if (gtk_widget_get_realized (GTK_WIDGET(simple->canvas))) #else if (GTK_WIDGET_REALIZED (simple->canvas)) #endif gtk_widget_set_parent_window (witem->widget, simple->canvas->canvas_window); gtk_widget_set_parent (witem->widget, GTK_WIDGET (simple->canvas)); } } else { if (witem->widget) gtk_widget_unparent (witem->widget); } } }
static void goo_canvas_widget_set_widget (GooCanvasWidget *witem, GtkWidget *widget) { GooCanvasItemSimple *simple = (GooCanvasItemSimple*) witem; if (witem->widget) { g_object_set_data (G_OBJECT (witem->widget), "goo-canvas-item", NULL); gtk_widget_unparent (witem->widget); g_object_unref (witem->widget); witem->widget = NULL; } if (widget) { witem->widget = widget; g_object_ref (witem->widget); g_object_set_data (G_OBJECT (witem->widget), "goo-canvas-item", witem); if (simple->simple_data->visibility <= GOO_CANVAS_ITEM_INVISIBLE) gtk_widget_hide (widget); else gtk_widget_show (widget); if (simple->canvas) { #if GTK_CHECK_VERSION(2, 19, 0) if (gtk_widget_get_realized (GTK_WIDGET(simple->canvas))) #else if (GTK_WIDGET_REALIZED (simple->canvas)) #endif gtk_widget_set_parent_window (widget, simple->canvas->canvas_window); gtk_widget_set_parent (widget, GTK_WIDGET (simple->canvas)); } } }
static void ViewOvBoxSetChild(ViewOvBox *that, // IN GtkWidget **child, // IN GdkWindow *childWin, // IN GtkWidget *widget) // IN { GtkWidget *oldChild = *child; if (oldChild) { g_object_ref(oldChild); gtk_container_remove(GTK_CONTAINER(that), oldChild); } *child = widget; if (*child) { gtk_widget_set_parent_window(widget, childWin); gtk_container_add(GTK_CONTAINER(that), *child); } if (oldChild) { g_object_unref(oldChild); } }
GtkWidget* gtk_xtbin_new (GdkWindow *parent_window, String * f) { GtkXtBin *xtbin; gpointer user_data; assert(parent_window != NULL); xtbin = gtk_type_new (GTK_TYPE_XTBIN); 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_window_get_visual(parent_window )), GDK_COLORMAP_XCOLORMAP(gdk_window_get_colormap(parent_window)), gdk_window_get_visual(parent_window )->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; } /* If this is the first running widget, hook this display into the mainloop */ if (0 == num_widgets) { int cnumber; /* * hook Xt event loop into the glib event loop. */ /* the assumption is that gtk_init has already been called */ GSource* gs = g_source_new(&xt_event_funcs, sizeof(GSource)); if (!gs) { return NULL; } g_source_set_priority(gs, GDK_PRIORITY_EVENTS); g_source_set_can_recurse(gs, TRUE); tag = g_source_attach(gs, (GMainContext*)NULL); #ifdef VMS cnumber = XConnectionNumber(xtdisplay); #else cnumber = ConnectionNumber(xtdisplay); #endif xt_event_poll_fd.fd = cnumber; xt_event_poll_fd.events = G_IO_IN; xt_event_poll_fd.revents = 0; /* hmm... is this correct? */ g_main_context_add_poll ((GMainContext*)NULL, &xt_event_poll_fd, G_PRIORITY_LOW); /* add a timer so that we can poll and process Xt timers */ xt_polling_timer_id = gtk_timeout_add(25, (GtkFunction)xt_event_polling_timer_callback, xtdisplay); } /* Bump up our usage count */ num_widgets++; /* 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)); return GTK_WIDGET (xtbin); }
static void gtk_offscreen_box_realize (GtkWidget *widget) { GtkOffscreenBox *offscreen_box = GTK_OFFSCREEN_BOX (widget); GdkWindowAttr attributes; gint attributes_mask; gint border_width; GtkRequisition child_requisition; int start_y = 0; gtk_widget_set_realized (widget, TRUE); border_width = GTK_CONTAINER (widget)->border_width; attributes.x = widget->allocation.x + border_width; attributes.y = widget->allocation.y + border_width; attributes.width = widget->allocation.width - 2 * border_width; attributes.height = widget->allocation.height - 2 * border_width; attributes.window_type = GDK_WINDOW_CHILD; attributes.event_mask = gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_SCROLL_MASK | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK; attributes.visual = gtk_widget_get_visual (widget); attributes.colormap = gtk_widget_get_colormap (widget); attributes.wclass = GDK_INPUT_OUTPUT; 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); g_signal_connect (widget->window, "pick-embedded-child", G_CALLBACK (pick_offscreen_child), offscreen_box); attributes.window_type = GDK_WINDOW_OFFSCREEN; /* Child 1 */ attributes.x = attributes.y = 0; if (offscreen_box->child1 && gtk_widget_get_visible (offscreen_box->child1)) { attributes.width = offscreen_box->child1->allocation.width; attributes.height = offscreen_box->child1->allocation.height; start_y += offscreen_box->child1->allocation.height; } offscreen_box->offscreen_window1 = gdk_window_new (gtk_widget_get_root_window (widget), &attributes, attributes_mask); gdk_window_set_user_data (offscreen_box->offscreen_window1, widget); if (offscreen_box->child1) gtk_widget_set_parent_window (offscreen_box->child1, offscreen_box->offscreen_window1); gdk_offscreen_window_set_embedder (offscreen_box->offscreen_window1, widget->window); g_signal_connect (offscreen_box->offscreen_window1, "to-embedder", G_CALLBACK (offscreen_window_to_parent1), offscreen_box); g_signal_connect (offscreen_box->offscreen_window1, "from-embedder", G_CALLBACK (offscreen_window_from_parent1), offscreen_box); /* Child 2 */ attributes.y = start_y; child_requisition.width = child_requisition.height = 0; if (offscreen_box->child2 && gtk_widget_get_visible (offscreen_box->child2)) { attributes.width = offscreen_box->child2->allocation.width; attributes.height = offscreen_box->child2->allocation.height; } offscreen_box->offscreen_window2 = gdk_window_new (gtk_widget_get_root_window (widget), &attributes, attributes_mask); gdk_window_set_user_data (offscreen_box->offscreen_window2, widget); if (offscreen_box->child2) gtk_widget_set_parent_window (offscreen_box->child2, offscreen_box->offscreen_window2); gdk_offscreen_window_set_embedder (offscreen_box->offscreen_window2, widget->window); g_signal_connect (offscreen_box->offscreen_window2, "to-embedder", G_CALLBACK (offscreen_window_to_parent2), offscreen_box); g_signal_connect (offscreen_box->offscreen_window2, "from-embedder", G_CALLBACK (offscreen_window_from_parent2), offscreen_box); widget->style = gtk_style_attach (widget->style, widget->window); gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL); gtk_style_set_background (widget->style, offscreen_box->offscreen_window1, GTK_STATE_NORMAL); gtk_style_set_background (widget->style, offscreen_box->offscreen_window2, GTK_STATE_NORMAL); gdk_window_show (offscreen_box->offscreen_window1); gdk_window_show (offscreen_box->offscreen_window2); }