void panel_menu_button_set_dnd_enabled (PanelMenuButton *button, gboolean dnd_enabled) { g_return_if_fail (PANEL_IS_MENU_BUTTON (button)); dnd_enabled = dnd_enabled != FALSE; if (button->priv->dnd_enabled == dnd_enabled) return; if (dnd_enabled) { static GtkTargetEntry dnd_targets [] = { { "application/x-mate-panel-applet-internal", 0, 0 } }; char *icon; gtk_widget_set_has_window (GTK_WIDGET (button), TRUE); gtk_drag_source_set (GTK_WIDGET (button), GDK_BUTTON1_MASK, dnd_targets, 1, GDK_ACTION_COPY | GDK_ACTION_MOVE); icon = panel_menu_button_get_icon (button); if (icon != NULL) { gtk_drag_source_set_icon_name (GTK_WIDGET (button), icon); g_free (icon); } gtk_widget_set_has_window (GTK_WIDGET (button), FALSE); } else gtk_drag_source_unset (GTK_WIDGET (button)); }
void panel_action_button_set_dnd_enabled (PanelActionButton *button, gboolean enabled) { g_return_if_fail (PANEL_IS_ACTION_BUTTON (button)); if (!button->priv->type) return; /* wait until we know what type it is */ enabled = enabled != FALSE; if (button->priv->dnd_enabled == enabled) return; if (enabled) { static GtkTargetEntry dnd_targets [] = { { "application/x-mate-panel-applet-internal", 0, 0 } }; gtk_widget_set_has_window (GTK_WIDGET (button), TRUE); gtk_drag_source_set (GTK_WIDGET (button), GDK_BUTTON1_MASK, dnd_targets, 1, GDK_ACTION_COPY | GDK_ACTION_MOVE); if (actions [button->priv->type].icon_name != NULL) gtk_drag_source_set_icon_name (GTK_WIDGET (button), actions [button->priv->type].icon_name); gtk_widget_set_has_window (GTK_WIDGET (button), FALSE); } else gtk_drag_source_unset (GTK_WIDGET (button)); button->priv->dnd_enabled = enabled; g_object_notify (G_OBJECT (button), "dnd-enabled"); }
void panel_launcher_set_dnd_enabled (Launcher *launcher, gboolean dnd_enabled) { GdkPixbuf *pixbuf; if (dnd_enabled) { static GtkTargetEntry dnd_targets[] = { { (gchar *) "application/x-panel-icon-internal", 0, TARGET_ICON_INTERNAL }, { (gchar *) "text/uri-list", 0, TARGET_URI_LIST } }; gtk_widget_set_has_window (launcher->button, TRUE); gtk_drag_source_set (launcher->button, GDK_BUTTON1_MASK, dnd_targets, 2, GDK_ACTION_COPY | GDK_ACTION_MOVE); //FIXME: this doesn't work since the pixbuf isn't loaded yet pixbuf = button_widget_get_pixbuf (BUTTON_WIDGET (launcher->button)); if (pixbuf) { gtk_drag_source_set_icon_pixbuf (launcher->button, pixbuf); g_object_unref (pixbuf); } gtk_widget_set_has_window (launcher->button, FALSE); } else gtk_drag_source_unset (launcher->button); }
/* Plugin constructor. */ static GtkWidget *space_constructor(Panel *panel, config_setting_t *settings) { /* Allocate plugin context and set into Plugin private data pointer. */ SpacePlugin * sp = g_new0(SpacePlugin, 1); GtkWidget * p; /* Load parameters from the configuration file. */ config_setting_lookup_int(settings, "Size", &sp->size); /* Save construction pointers */ sp->panel = panel; sp->settings = settings; /* Default the size parameter. */ if (sp->size == 0) sp->size = 2; /* Allocate top level widget and set into Plugin widget pointer. */ p = gtk_event_box_new(); lxpanel_plugin_set_data(p, sp, g_free); #if GTK_CHECK_VERSION(2,18,0) gtk_widget_set_has_window(p,FALSE); #else GTK_WIDGET_SET_FLAGS(p, GTK_NO_WINDOW); #endif gtk_widget_add_events(p, GDK_BUTTON_PRESS_MASK); gtk_container_set_border_width(GTK_CONTAINER(p), 0); /* Apply the configuration and show the widget. */ space_apply_configuration(p); return p; }
static void gtk_expander_init (GtkExpander *expander) { GtkExpanderPrivate *priv; expander->priv = priv = GTK_EXPANDER_GET_PRIVATE (expander); gtk_widget_set_can_focus (GTK_WIDGET (expander), TRUE); gtk_widget_set_has_window (GTK_WIDGET (expander), FALSE); priv->label_widget = NULL; priv->event_window = NULL; priv->spacing = 0; priv->expander_style = GTK_EXPANDER_COLLAPSED; priv->animation_timeout = 0; priv->expanded = FALSE; priv->use_underline = FALSE; priv->use_markup = FALSE; priv->button_down = FALSE; priv->prelight = FALSE; priv->label_fill = FALSE; priv->expand_timer = 0; gtk_drag_dest_set (GTK_WIDGET (expander), 0, NULL, 0, 0); gtk_drag_dest_set_track_motion (GTK_WIDGET (expander), TRUE); }
static void progress_simple_container_init (ProgressSimpleContainer* self) { PRIV (self) = G_TYPE_INSTANCE_GET_PRIVATE (self, PROGRESS_TYPE_SIMPLE_CONTAINER, ProgressSimpleContainerPrivate); gtk_widget_set_has_window (GTK_WIDGET (self), FALSE); }
static void progress_simple_widget_impl_init (ProgressSimpleWidgetImpl* self) { PRIV (self) = G_TYPE_INSTANCE_GET_PRIVATE (self, PROGRESS_TYPE_SIMPLE_WIDGET_IMPL, ProgressSimpleWidgetImplPrivate); gtk_widget_set_has_window (GTK_WIDGET (self), FALSE); }
static void cell_area_scaffold_init (CellAreaScaffold *scaffold) { CellAreaScaffoldPrivate *priv; scaffold->priv = G_TYPE_INSTANCE_GET_PRIVATE (scaffold, TYPE_CELL_AREA_SCAFFOLD, CellAreaScaffoldPrivate); priv = scaffold->priv; priv->area = gtk_cell_area_box_new (); priv->context = gtk_cell_area_create_context (priv->area); priv->row_data = g_array_new (FALSE, FALSE, sizeof (RowData)); gtk_widget_set_has_window (GTK_WIDGET (scaffold), FALSE); gtk_widget_set_can_focus (GTK_WIDGET (scaffold), TRUE); priv->size_changed_id = g_signal_connect (priv->context, "notify", G_CALLBACK (size_changed_cb), scaffold); priv->focus_changed_id = g_signal_connect (priv->area, "focus-changed", G_CALLBACK (focus_changed_cb), scaffold); priv->add_editable_id = g_signal_connect (priv->area, "add-editable", G_CALLBACK (add_editable_cb), scaffold); priv->remove_editable_id = g_signal_connect (priv->area, "remove-editable", G_CALLBACK (remove_editable_cb), scaffold); }
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 columns_init(Columns *cols) { gtk_widget_set_has_window(GTK_WIDGET(cols), FALSE); cols->children = NULL; cols->spacing = 0; }
static void dma_data_view_instance_init (DmaDataView *view) { view->buffer = NULL; gtk_widget_set_has_window (GTK_WIDGET (view), FALSE); }
/* Plugin constructor. */ static int dclock_constructor(Plugin * p) { /* Allocate and initialize plugin context and set into Plugin private data pointer. */ DClockPlugin * dc = g_new0(DClockPlugin, 1); plugin_set_priv(p, dc); dc->plugin = p; /* Initialize the clock display. */ dc->clock_format = g_strdup(_(DEFAULT_CLOCK_FORMAT)); dc->tooltip_format = g_strdup(_(DEFAULT_TIP_FORMAT)); su_json_read_options(plugin_inner_json(p), option_definitions, dc); /* Allocate top level widget and set into Plugin widget pointer. */ GtkWidget * pwid = gtk_event_box_new(); plugin_set_widget(p, pwid); gtk_widget_set_has_window(pwid, FALSE); GtkWidget * hbox = gtk_hbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(pwid), hbox); gtk_widget_show(hbox); dc->label_box = gtk_hbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(hbox), dc->label_box); /* Connect signals. */ g_signal_connect(G_OBJECT (pwid), "button_press_event", G_CALLBACK(dclock_button_press_event), (gpointer) p); dclock_apply_configuration(p); /* Show the widget and return. */ gtk_widget_show(pwid); return 1; }
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 gs_popular_tile_init (GsPopularTile *tile) { gtk_widget_set_has_window (GTK_WIDGET (tile), FALSE); gtk_widget_init_template (GTK_WIDGET (tile)); gs_star_widget_set_icon_size (GS_STAR_WIDGET (tile->stars), 12); }
static void gtk_color_swatch_init (GtkColorSwatch *swatch) { GtkCssNode *widget_node; GtkStyleContext *context; swatch->priv = gtk_color_swatch_get_instance_private (swatch); swatch->priv->use_alpha = TRUE; swatch->priv->selectable = TRUE; swatch->priv->has_menu = TRUE; gtk_widget_set_can_focus (GTK_WIDGET (swatch), TRUE); gtk_widget_set_has_window (GTK_WIDGET (swatch), FALSE); swatch->priv->long_press_gesture = gtk_gesture_long_press_new (GTK_WIDGET (swatch)); gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (swatch->priv->long_press_gesture), TRUE); g_signal_connect (swatch->priv->long_press_gesture, "pressed", G_CALLBACK (hold_action), swatch); swatch->priv->multipress_gesture = gtk_gesture_multi_press_new (GTK_WIDGET (swatch)); gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (swatch->priv->multipress_gesture), 0); g_signal_connect (swatch->priv->multipress_gesture, "pressed", G_CALLBACK (tap_action), swatch); widget_node = gtk_widget_get_css_node (GTK_WIDGET (swatch)); swatch->priv->overlay_node = gtk_css_node_new (); gtk_css_node_set_name (swatch->priv->overlay_node, I_("overlay")); gtk_css_node_set_parent (swatch->priv->overlay_node, widget_node); gtk_css_node_set_state (swatch->priv->overlay_node, gtk_css_node_get_state (widget_node)); g_object_unref (swatch->priv->overlay_node); context = gtk_widget_get_style_context (GTK_WIDGET (swatch)); gtk_style_context_add_class (context, "activatable"); }
static void gx_selector_init(GxSelector *selector) { selector->priv = G_TYPE_INSTANCE_GET_PRIVATE(selector, GX_TYPE_SELECTOR, GxSelectorPrivate); gtk_widget_set_has_window(GTK_WIDGET(selector), FALSE); gtk_widget_set_can_focus(GTK_WIDGET(selector), TRUE); selector->icon = NULL; }
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 void gtk_level_bar_init (GtkLevelBar *self) { GtkStyleContext *context; self->priv = gtk_level_bar_get_instance_private (self); context = gtk_widget_get_style_context (GTK_WIDGET (self)); gtk_style_context_add_class (context, GTK_STYLE_CLASS_LEVEL_BAR); self->priv->cur_value = 0.0; self->priv->min_value = 0.0; self->priv->max_value = 1.0; gtk_level_bar_ensure_offset (self, GTK_LEVEL_BAR_OFFSET_LOW, 0.25); gtk_level_bar_ensure_offset (self, GTK_LEVEL_BAR_OFFSET_HIGH, 0.75); gtk_level_bar_update_level_style_classes (self); self->priv->bar_mode = GTK_LEVEL_BAR_MODE_CONTINUOUS; gtk_level_bar_update_mode_style_classes (self); /* set initial orientation and style classes */ self->priv->orientation = GTK_ORIENTATION_HORIZONTAL; _gtk_orientable_set_style_classes (GTK_ORIENTABLE (self)); self->priv->inverted = FALSE; gtk_widget_set_has_window (GTK_WIDGET (self), FALSE); }
GtkWidget* wxPizza::New(long windowStyle) { GtkWidget* widget = GTK_WIDGET(g_object_new(type(), NULL)); wxPizza* pizza = WX_PIZZA(widget); pizza->m_children = NULL; pizza->m_scroll_x = 0; pizza->m_scroll_y = 0; pizza->m_windowStyle = windowStyle; #ifdef __WXGTK3__ gtk_widget_set_has_window(widget, true); #else gtk_fixed_set_has_window(GTK_FIXED(widget), true); #endif gtk_widget_add_events(widget, GDK_EXPOSURE_MASK | GDK_SCROLL_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_MOTION_MASK | GDK_BUTTON1_MOTION_MASK | GDK_BUTTON2_MOTION_MASK | GDK_BUTTON3_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_FOCUS_CHANGE_MASK); return widget; }
static void gb_slider_init (GbSlider *self) { GbSliderPrivate *priv = gb_slider_get_instance_private (self); priv->position = GB_SLIDER_NONE; priv->children = g_ptr_array_new_with_free_func ((GDestroyNotify)gb_slider_child_free); priv->v_adj = g_object_new (GTK_TYPE_ADJUSTMENT, "lower", -1.0, "upper", 1.0, "value", 0.0, NULL); g_signal_connect_object (priv->v_adj, "value-changed", G_CALLBACK (gtk_widget_queue_resize), self, G_CONNECT_SWAPPED); priv->h_adj = g_object_new (GTK_TYPE_ADJUSTMENT, "lower", -1.0, "upper", 1.0, "value", 0.0, NULL); g_signal_connect_object (priv->h_adj, "value-changed", G_CALLBACK (gtk_widget_queue_resize), self, G_CONNECT_SWAPPED); gtk_widget_set_has_window (GTK_WIDGET (self), FALSE); }
static void gtk_switch_init (GtkSwitch *self) { GtkGesture *gesture; self->priv = gtk_switch_get_instance_private (self); self->priv->use_action_appearance = TRUE; gtk_widget_set_has_window (GTK_WIDGET (self), FALSE); gtk_widget_set_can_focus (GTK_WIDGET (self), TRUE); gesture = gtk_gesture_multi_press_new (GTK_WIDGET (self)); gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (gesture), FALSE); gtk_gesture_single_set_exclusive (GTK_GESTURE_SINGLE (gesture), TRUE); g_signal_connect (gesture, "pressed", G_CALLBACK (gtk_switch_multipress_gesture_pressed), self); g_signal_connect (gesture, "released", G_CALLBACK (gtk_switch_multipress_gesture_released), self); gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (gesture), GTK_PHASE_BUBBLE); self->priv->multipress_gesture = gesture; gesture = gtk_gesture_pan_new (GTK_WIDGET (self), GTK_ORIENTATION_HORIZONTAL); gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (gesture), FALSE); gtk_gesture_single_set_exclusive (GTK_GESTURE_SINGLE (gesture), TRUE); g_signal_connect (gesture, "pan", G_CALLBACK (gtk_switch_pan_gesture_pan), self); g_signal_connect (gesture, "drag-end", G_CALLBACK (gtk_switch_pan_gesture_drag_end), self); gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (gesture), GTK_PHASE_BUBBLE); self->priv->pan_gesture = gesture; }
static void panel_icon_grid_init(PanelIconGrid *ig) { gtk_widget_set_has_window(GTK_WIDGET(ig), FALSE); gtk_widget_set_redraw_on_allocate(GTK_WIDGET(ig), FALSE); ig->orientation = GTK_ORIENTATION_HORIZONTAL; }
GtkWidget* wxPizza::New(long windowStyle) { GtkWidget* widget = GTK_WIDGET(g_object_new(type(), NULL)); wxPizza* pizza = WX_PIZZA(widget); pizza->m_scroll_x = 0; pizza->m_scroll_y = 0; pizza->m_is_scrollable = (windowStyle & (wxHSCROLL | wxVSCROLL)) != 0; // mask off border styles not useable with wxPizza pizza->m_border_style = int(windowStyle & BORDER_STYLES); #if GTK_CHECK_VERSION(3,0,0) || defined(GTK_DISABLE_DEPRECATED) gtk_widget_set_has_window(widget, true); #else gtk_fixed_set_has_window(GTK_FIXED(widget), true); #endif gtk_widget_add_events(widget, GDK_EXPOSURE_MASK | GDK_SCROLL_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_MOTION_MASK | GDK_BUTTON1_MOTION_MASK | GDK_BUTTON2_MOTION_MASK | GDK_BUTTON3_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_FOCUS_CHANGE_MASK); return widget; }
static void gimp_ruler_init (GimpRuler *ruler) { GimpRulerPrivate *priv = GIMP_RULER_GET_PRIVATE (ruler); gtk_widget_set_has_window (GTK_WIDGET (ruler), FALSE); priv->orientation = GTK_ORIENTATION_HORIZONTAL; priv->unit = GIMP_UNIT_PIXEL; priv->lower = 0; priv->upper = 0; priv->position = 0; priv->max_size = 0; priv->backing_store = NULL; priv->backing_store_valid = FALSE; priv->last_pos_rect.x = 0; priv->last_pos_rect.y = 0; priv->last_pos_rect.width = 0; priv->last_pos_rect.height = 0; priv->pos_redraw_idle_id = 0; priv->font_scale = DEFAULT_RULER_FONT_SCALE; }
static void gtk_switch_init (GtkSwitch *self) { self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GTK_TYPE_SWITCH, GtkSwitchPrivate); self->priv->use_action_appearance = TRUE; gtk_widget_set_has_window (GTK_WIDGET (self), FALSE); gtk_widget_set_can_focus (GTK_WIDGET (self), TRUE); }
static void gs_review_row_init (GsReviewRow *row) { GsReviewRowPrivate *priv = gs_review_row_get_instance_private (row); priv->network_available = TRUE; gtk_widget_set_has_window (GTK_WIDGET (row), FALSE); gtk_widget_init_template (GTK_WIDGET (row)); }
static void gtk_switch_init (GtkSwitch *self) { self->priv = gtk_switch_get_instance_private (self); self->priv->use_action_appearance = TRUE; gtk_widget_set_has_window (GTK_WIDGET (self), FALSE); gtk_widget_set_can_focus (GTK_WIDGET (self), TRUE); }
static void mcus_led_init (MCUSLED *self) { self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, MCUS_TYPE_LED, MCUSLEDPrivate); /* We don't have a window of our own; we use our parent's */ gtk_widget_set_has_window (GTK_WIDGET (self), FALSE); }
static void gd_stack_init (GdStack *stack) { stack->priv = GD_STACK_GET_PRIVATE (stack); gtk_widget_set_has_window ((GtkWidget*) stack, TRUE); gtk_widget_set_redraw_on_allocate ((GtkWidget*) stack, TRUE); }
static void gtk_cell_view_init (GtkCellView *cellview) { cellview->priv = gtk_cell_view_get_instance_private (cellview); cellview->priv->orientation = GTK_ORIENTATION_HORIZONTAL; gtk_widget_set_has_window (GTK_WIDGET (cellview), FALSE); }