自学教程：C++ GTK_WIDGET_CLASS函数代码示例

static voidsexy_icon_entry_size_request(GtkWidget *widget, GtkRequisition *requisition){//	GtkEntry *gtkentry;	SexyIconEntry *entry;	gint icon_widths = 0;	int i;//	gtkentry = GTK_ENTRY(widget);	entry    = SEXY_ICON_ENTRY(widget);	for (i = 0; i < MAX_ICONS; i++)	{		int icon_width = get_icon_width(entry, i);		if (icon_width > 0)			icon_widths += icon_width + ICON_MARGIN;	}	GTK_WIDGET_CLASS(parent_class)->size_request(widget, requisition);	if (icon_widths > requisition->width)		requisition->width += icon_widths;}

static voidwidget_overlay_class_init (WidgetOverlayClass *klass){	GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);	GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);	parent_class = g_type_class_peek_parent (klass);	widget_class->realize = widget_overlay_realize;	widget_class->unrealize = widget_overlay_unrealize;	widget_class->get_preferred_width = widget_overlay_get_preferred_width;	widget_class->get_preferred_height = widget_overlay_get_preferred_height;	widget_class->size_allocate = widget_overlay_size_allocate;	widget_class->draw = widget_overlay_draw;	widget_class->event = widget_overlay_event;	widget_class->show = widget_overlay_show;	g_signal_override_class_closure (g_signal_lookup ("damage-event", GTK_TYPE_WIDGET),					 WIDGET_OVERLAY_TYPE,					 g_cclosure_new (G_CALLBACK (widget_overlay_damage),							 NULL, NULL));	container_class->add = widget_overlay_add;	container_class->remove = widget_overlay_remove;	container_class->forall = widget_overlay_forall;	G_OBJECT_CLASS (klass)->dispose = widget_overlay_dispose;	G_OBJECT_CLASS (klass)->finalize = widget_overlay_finalize;	/* Properties */        G_OBJECT_CLASS (klass)->set_property = widget_overlay_set_property;        G_OBJECT_CLASS (klass)->get_property = widget_overlay_get_property;	g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_ADD_SCALE,                                         g_param_spec_boolean ("add-scale", NULL, NULL,                                                               FALSE,                                                               (G_PARAM_READABLE | G_PARAM_WRITABLE)));}

    static gbooleangtk_form_draw(GtkWidget *widget, cairo_t *cr){    GList   *tmp_list = NULL;    GtkForm *form     = NULL;    g_return_val_if_fail(GTK_IS_FORM(widget), FALSE);    gtk_form_render_background(widget, cr);    form = GTK_FORM(widget);    for (tmp_list = form->children; tmp_list; tmp_list = tmp_list->next)    {	GtkFormChild * const formchild = tmp_list->data;	if (!gtk_widget_get_has_window(formchild->widget) &&		gtk_cairo_should_draw_window(cr, formchild->window))	{	    /* To get gtk_widget_draw() to work, it is required to call	     * gtk_widget_size_allocate() in advance with a well-posed	     * allocation for a given child widget in order to set a	     * certain private GtkWidget variable, called	     * widget->priv->alloc_need, to the proper value; otherwise,	     * gtk_widget_draw() fails and the relevant scrollbar won't	     * appear on the screen.	     *	     * Calling gtk_form_position_child() like this is one of ways	     * to make sure of that. */	    gtk_form_position_child(form, formchild, TRUE);	    gtk_form_render_background(formchild->widget, cr);	}    }    return GTK_WIDGET_CLASS(gtk_form_parent_class)->draw(widget, cr);}

static voidgb_terminal_view_class_init (GbTerminalViewClass *klass){  GObjectClass *object_class = G_OBJECT_CLASS (klass);  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);  IdeLayoutViewClass *view_class = IDE_LAYOUT_VIEW_CLASS (klass);  object_class->finalize = gb_terminal_view_finalize;  object_class->set_property = gb_terminal_view_set_property;  widget_class->realize = gb_terminal_realize;  widget_class->get_preferred_width = gb_terminal_get_preferred_width;  widget_class->get_preferred_height = gb_terminal_get_preferred_height;  widget_class->grab_focus = gb_terminal_grab_focus;  view_class->get_title = gb_terminal_get_title;  view_class->create_split = gb_terminal_create_split;  view_class->set_split_view =  gb_terminal_set_split_view;  gtk_widget_class_set_template_from_resource (widget_class, "/org/gnome/builder/plugins/terminal/gb-terminal-view.ui");  gtk_widget_class_bind_template_child (widget_class, GbTerminalView, terminal_top);  gtk_widget_class_bind_template_child (widget_class, GbTerminalView, bottom_container);  g_type_ensure (VTE_TYPE_TERMINAL);  properties [PROP_FONT_NAME] =    g_param_spec_string ("font-name",                         "Font Name",                         "Font Name",                         NULL,                         (G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS));  g_object_class_install_properties (object_class, LAST_PROP, properties);  g_type_ensure (GB_TYPE_TERMINAL);}

static voidcontact_list_view_drag_begin (GtkWidget      *widget,			      GdkDragContext *context){	EmpathyContactListViewPriv *priv;	GtkTreeSelection          *selection;	GtkTreeModel              *model;	GtkTreePath               *path;	GtkTreeIter                iter;	priv = GET_PRIV (widget);	GTK_WIDGET_CLASS (empathy_contact_list_view_parent_class)->drag_begin (widget,									      context);	selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget));	if (!gtk_tree_selection_get_selected (selection, &model, &iter)) {		return;	}	path = gtk_tree_model_get_path (model, &iter);	priv->drag_row = gtk_tree_row_reference_new (model, path);	gtk_tree_path_free (path);}

static voidgb_search_box_map (GtkWidget *widget){  GbSearchBox *self = (GbSearchBox *)widget;  GtkWidget *toplevel;  g_return_if_fail (GB_IS_SEARCH_BOX (self));  GTK_WIDGET_CLASS (gb_search_box_parent_class)->map (widget);  gtk_widget_set_sensitive (GTK_WIDGET (self->button), FALSE);  toplevel = gtk_widget_get_toplevel (widget);  if (GB_IS_WORKBENCH (toplevel))    {      gb_set_weak_pointer (toplevel, &self->workbench);      self->set_focus_handler =        g_signal_connect_object (toplevel,                                 "set-focus",                                 G_CALLBACK (gb_search_box_workbench_set_focus),                                 self,                                 G_CONNECT_SWAPPED | G_CONNECT_AFTER);    }}

static AtkObject *mcus_led_get_accessible (GtkWidget *widget){	static gboolean first_time = TRUE;	if (first_time) {		AtkObjectFactory *factory;		AtkRegistry *registry;		GType derived_type, derived_atk_type;		/* Figure out whether accessibility is enabled by looking at the type of the accessible object which would be created for		 * the parent type of MCUSLED. */		derived_type = g_type_parent (MCUS_TYPE_LED);		registry = atk_get_default_registry ();		factory = atk_registry_get_factory (registry, derived_type);		derived_atk_type = atk_object_factory_get_accessible_type (factory);		if (g_type_is_a (derived_atk_type, GTK_TYPE_ACCESSIBLE))			atk_registry_set_factory_type (registry, MCUS_TYPE_LED, mcus_led_accessible_factory_get_type ());		first_time = FALSE;	}	return GTK_WIDGET_CLASS (mcus_led_parent_class)->get_accessible (widget);}

static void ygtk_fixed_size_allocate (GtkWidget *widget, GtkAllocation *allocation){	YGtkFixed *fixed = YGTK_FIXED (widget);	fixed->set_size_cb (fixed, allocation->width, allocation->height, fixed->data);	GSList *i;	for (i = fixed->children; i; i = i->next) {		YGtkFixedChild *child = i->data;		int x = child->x;		if (gtk_widget_get_default_direction() == GTK_TEXT_DIR_RTL)			x = allocation->width - (child->x + child->width);		x += allocation->x;		int y = child->y + allocation->y;		GtkAllocation child_alloc =			{ x, y, MAX (child->width, 1), MAX (child->height, 1) };		GtkRequisition min_child_req;		GtkRequisition nat_child_req;		gtk_widget_get_preferred_size (child->widget, &min_child_req, &nat_child_req);		gtk_widget_size_allocate (child->widget, &child_alloc);	}	GTK_WIDGET_CLASS (ygtk_fixed_parent_class)->size_allocate (widget, allocation);}

static voidgtk_revealer_real_get_preferred_width (GtkWidget *widget,                                       gint      *minimum_width_out,                                       gint      *natural_width_out){  GtkRevealer *revealer = GTK_REVEALER (widget);  GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer);  gint minimum_width;  gint natural_width;  GtkRevealerTransitionType transition;  GTK_WIDGET_CLASS (gtk_revealer_parent_class)->get_preferred_width (widget, &minimum_width, &natural_width);  transition = effective_transition (revealer);  if (transition == GTK_REVEALER_TRANSITION_TYPE_NONE ||      transition == GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT ||      transition == GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT)    natural_width = round (natural_width * priv->current_pos);  minimum_width = MIN (minimum_width, natural_width);  *minimum_width_out = minimum_width;  *natural_width_out = natural_width;}

static voidgimp_unit_combo_box_style_set (GtkWidget *widget,                               GtkStyle  *prev_style){  GtkCellLayout   *layout;  GtkCellRenderer *cell;  gdouble          scale;  GTK_WIDGET_CLASS (parent_class)->style_set (widget, prev_style);  gtk_widget_style_get (widget, "label-scale", &scale, NULL);  /*  hackedehack ...  */  layout = GTK_CELL_LAYOUT (gtk_bin_get_child (GTK_BIN (widget)));  gtk_cell_layout_clear (layout);  cell = g_object_new (GTK_TYPE_CELL_RENDERER_TEXT,                       "scale", scale,                       NULL);  gtk_cell_layout_pack_start (layout, cell, TRUE);  gtk_cell_layout_set_attributes (layout, cell,                                  "text",  GIMP_UNIT_STORE_UNIT_SHORT_FORMAT,                                  NULL);}

static voidgtk_revealer_real_get_preferred_height (GtkWidget *widget,                                        gint      *minimum_height_out,                                        gint      *natural_height_out){  GtkRevealer *revealer = GTK_REVEALER (widget);  GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer);  gint minimum_height;  gint natural_height;  GtkRevealerTransitionType transition;  GTK_WIDGET_CLASS (gtk_revealer_parent_class)->get_preferred_height (widget, &minimum_height, &natural_height);  transition = effective_transition (revealer);  if (transition == GTK_REVEALER_TRANSITION_TYPE_NONE ||      transition == GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP ||      transition == GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN)    natural_height = round (natural_height * priv->current_pos);  minimum_height = MIN (minimum_height, natural_height);  *minimum_height_out = minimum_height;  *natural_height_out = natural_height;}

static gbooleanmatecomponent_plug_expose_event (GtkWidget      *widget,			  GdkEventExpose *event){	gboolean retval;	retval = GTK_WIDGET_CLASS (matecomponent_plug_parent_class)->expose_event (widget, event);	dbgprintf ("matecomponent_plug_expose_event %p (%d, %d), (%d, %d)"		 "%s (%d && %d == %d)/n",		 widget,		 event->area.x, event->area.y,		 event->area.width, event->area.height,		 GTK_WIDGET_TOPLEVEL (widget) ? "toplevel" : "bin class",		 GTK_WIDGET_VISIBLE (widget),		 GTK_WIDGET_MAPPED (widget),		 GTK_WIDGET_DRAWABLE (widget));#ifdef DEBUG_CONTROL	gdk_draw_line (widget->window,		       widget->style->black_gc,		       event->area.x + event->area.width,		       event->area.y,		       event->area.x, 		       event->area.y + event->area.height);	gdk_draw_line (widget->window,		       widget->style->black_gc,		       widget->allocation.x,		       widget->allocation.y,		       widget->allocation.x + widget->allocation.width,		       widget->allocation.y + widget->allocation.height);#endif	return retval;}

static void class_init(void* g_class, void*){    GtkWidgetClass* widget_class = (GtkWidgetClass*)g_class;    widget_class->size_allocate = size_allocate;    widget_class->realize = realize;    widget_class->unrealize = unrealize;    widget_class->map = map;    widget_class->unmap = unmap;    wxPizzaClass* klass = (wxPizzaClass*)g_class;    // needed to make widget appear scrollable to GTK+    klass->set_scroll_adjustments = set_scroll_adjustments;    widget_class->set_scroll_adjustments_signal =        g_signal_new(            "set_scroll_adjustments",            G_TYPE_FROM_CLASS(g_class),            G_SIGNAL_RUN_LAST,            G_STRUCT_OFFSET(wxPizzaClass, set_scroll_adjustments),            NULL, NULL,            g_cclosure_user_marshal_VOID__OBJECT_OBJECT,            G_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);    parent_class = GTK_WIDGET_CLASS(g_type_class_peek_parent(g_class));}

static voidmosaic_search_box_class_init (MosaicSearchBoxClass *klass){  GObjectClass *gobject_class;  GtkWidgetClass *widget_class;  gobject_class = G_OBJECT_CLASS (klass);  widget_class = GTK_WIDGET_CLASS (klass);  gobject_class->constructor = mosaic_search_box_constructor;  gobject_class->dispose = mosaic_search_box_dispose;  gobject_class->set_property = mosaic_search_box_set_property;  gobject_class->get_property = mosaic_search_box_get_property;  widget_class->expose_event = mosaic_search_box_expose_event;  widget_class->size_request = mosaic_search_box_size_request;  obj_properties[PROP_TEXT] =    g_param_spec_string ("text",			 "Text in the search entry",			 "Text, displayed in search entry",			 NULL,			 G_PARAM_CONSTRUCT | G_PARAM_READWRITE);  g_object_class_install_property (gobject_class, PROP_TEXT, obj_properties [PROP_TEXT]);  search_box_signals [CHANGED] =    g_signal_new ("changed",		  G_TYPE_FROM_CLASS (gobject_class),		  G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,		  G_STRUCT_OFFSET (MosaicSearchBoxClass, changed),		  NULL, NULL,		  g_cclosure_marshal_VOID__VOID,		  G_TYPE_NONE, 0);}

static voidgimp_spin_scale_class_init (GimpSpinScaleClass *klass){  GObjectClass       *object_class      = G_OBJECT_CLASS (klass);  GtkWidgetClass     *widget_class      = GTK_WIDGET_CLASS (klass);  GtkSpinButtonClass *spin_button_class = GTK_SPIN_BUTTON_CLASS (klass);  object_class->dispose              = gimp_spin_scale_dispose;  object_class->finalize             = gimp_spin_scale_finalize;  object_class->set_property         = gimp_spin_scale_set_property;  object_class->get_property         = gimp_spin_scale_get_property;  widget_class->style_set            = gimp_spin_scale_style_set;#if WITH_GTKMM_3_0  widget_class->get_preferred_width  = gimp_spin_scale_get_preferred_width;  widget_class->get_preferred_height = gimp_spin_scale_get_preferred_height;  widget_class->draw                 = gimp_spin_scale_draw;#else  widget_class->size_request         = gimp_spin_scale_size_request;  widget_class->expose_event         = gimp_spin_scale_expose;#endif  widget_class->button_press_event   = gimp_spin_scale_button_press;  widget_class->button_release_event = gimp_spin_scale_button_release;  widget_class->motion_notify_event  = gimp_spin_scale_motion_notify;  widget_class->leave_notify_event   = gimp_spin_scale_leave_notify;  widget_class->key_press_event      = gimp_spin_scale_keypress;  spin_button_class->value_changed   = gimp_spin_scale_value_changed;  g_object_class_install_property (object_class, PROP_LABEL,                                   g_param_spec_string ("label", NULL, NULL,                                                        NULL,                                                        G_PARAM_READWRITE));  g_type_class_add_private (klass, sizeof (GimpSpinScalePrivate));}

static gbooleanon_draw(XmrWaitingWnd *wnd, cairo_t *cr, gpointer data){	PangoLayout *layout;	gint w, h;	XmrWaitingWndPrivate *priv = wnd->priv;		if (priv->tasks == NULL || priv->tasks->data == NULL)		return FALSE;		cairo_set_source_rgba(cr, 0, 0, 0, 0.7);	cairo_paint(cr);		layout = gtk_widget_create_pango_layout(GTK_WIDGET(wnd), ((Task *)priv->tasks->data)->info);		pango_layout_get_pixel_size(layout, &w, &h);	cairo_move_to(cr, (WAITING_WND_W - w) / 2, (WAITING_WND_H - h) / 2);	cairo_set_source_rgb(cr, 1, 1, 1);	pango_cairo_show_layout(cr, layout);		g_object_unref(layout);		return GTK_WIDGET_CLASS(xmr_waiting_wnd_parent_class)->draw(GTK_WIDGET(wnd), cr);}

static gbooleanfile_view_button_press_event (GtkWidget *widget, GdkEventButton *event){	gint retval = 		GTK_WIDGET_CLASS (file_view_parent_class)->button_press_event (widget,																	   event);	/* Ignore double-clicks and triple-clicks */	if (event->button == 3 && event->type == GDK_BUTTON_PRESS)    {		GtkTreePath *path;		/* Select file under cursor if not selected */        if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget),                        event->x,event->y, &path, NULL, NULL, NULL))		{			GtkTreeSelection *selection;			selection = gtk_tree_view_get_selection(GTK_TREE_VIEW (widget));	        if (!gtk_tree_selection_path_is_selected(selection, path))    	    {        	    gtk_tree_selection_unselect_all(selection);	            gtk_tree_selection_select_path(selection, path);    	        gtk_tree_view_set_cursor(GTK_TREE_VIEW(widget),        	                        path, NULL, FALSE);        	}        	gtk_tree_path_free (path);						file_view_do_popup_menu (widget, event);		      		return TRUE;		}    }	return 	retval;		}

static voidgtk_radio_menu_item_destroy (GtkWidget *widget){  GtkRadioMenuItem *radio_menu_item = GTK_RADIO_MENU_ITEM (widget);  GtkRadioMenuItemPrivate *priv = radio_menu_item->priv;  GtkWidget *old_group_singleton = NULL;  GtkRadioMenuItem *tmp_menu_item;  GSList *tmp_list;  gboolean was_in_group;  was_in_group = priv->group && priv->group->next;  priv->group = g_slist_remove (priv->group, radio_menu_item);  if (priv->group && !priv->group->next)    old_group_singleton = priv->group->data;  tmp_list = priv->group;  while (tmp_list)    {      tmp_menu_item = tmp_list->data;      tmp_list = tmp_list->next;      tmp_menu_item->priv->group = priv->group;    }  /* this radio menu item is no longer in the group */  priv->group = NULL;    if (old_group_singleton)    g_signal_emit (old_group_singleton, group_changed_signal, 0);  if (was_in_group)    g_signal_emit (radio_menu_item, group_changed_signal, 0);  GTK_WIDGET_CLASS (gtk_radio_menu_item_parent_class)->destroy (widget);}

static voidgtk_scrollbox_class_init (gpointer g_class, gpointer g_class_data){    GObjectClass *gobject_class = G_OBJECT_CLASS(g_class);  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(g_class);    GParamSpec *scrollbox_param_spec;  gobject_class->set_property = gtk_scrollbox_set_property;  gobject_class->get_property = gtk_scrollbox_get_property;    scrollbox_param_spec = g_param_spec_boolean("enablecb",                  "Enable callback",                  "Enable or disable the callback",                  FALSE,                  G_PARAM_READWRITE);  g_object_class_install_property (gobject_class,           GTK_SCROLLBOX_ENABLECB,           scrollbox_param_spec);  widget_class->expose_event = gtk_scrollbox_expose;  gobject_class->finalize = gtk_scrollbox_finalize;}

static gbooleanathena_entry_motion_notify (GtkWidget *widget, GdkEventMotion *event){	int result;	gboolean old_had, new_had;	int old_start, old_end, new_start, new_end;	GtkEditable *editable;	editable = GTK_EDITABLE (widget);	old_had = gtk_editable_get_selection_bounds (editable, &old_start, &old_end);	result = GTK_WIDGET_CLASS (athena_entry_parent_class)->motion_notify_event (widget, event);	/* Send a signal if dragging the mouse caused the selection to change. */	if (result) {		new_had = gtk_editable_get_selection_bounds (editable, &new_start, &new_end);		if (old_had != new_had || (old_had && (old_start != new_start || old_end != new_end))) {			g_signal_emit (widget, signals[SELECTION_CHANGED], 0);		}	}		return result;}

static voidgtr_message_table_class_init (GtrMessageTableClass * klass){    GObjectClass *object_class = G_OBJECT_CLASS (klass);    GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);    object_class->finalize = gtr_message_table_finalize;    object_class->set_property = gtr_message_table_set_property;    object_class->get_property = gtr_message_table_get_property;    g_object_class_install_property (object_class,                                     PROP_TAB,                                     g_param_spec_object ("tab",                                             "TAB",                                             "The active tab",                                             GTR_TYPE_TAB,                                             G_PARAM_READWRITE |                                             G_PARAM_CONSTRUCT_ONLY));    gtk_widget_class_set_template_from_resource (widget_class,            "/org/gnome/translator/gtr-message-table.ui");    gtk_widget_class_bind_template_child_private (widget_class, GtrMessageTable, treeview);}

static gboolean panel_applet_focus (GtkWidget        *widget,		    GtkDirectionType  dir){	gboolean ret;	GtkWidget *previous_focus_child;	g_return_val_if_fail (PANEL_IS_APPLET (widget), FALSE);	previous_focus_child = gtk_container_get_focus_child (GTK_CONTAINER (widget));	if (!previous_focus_child && !gtk_widget_has_focus (widget)) {		if (gtk_widget_get_has_tooltip (widget)) {			gtk_widget_set_can_focus (widget, TRUE);			gtk_widget_grab_focus (widget);			gtk_widget_set_can_focus (widget, FALSE);			return TRUE;		}	}	ret = GTK_WIDGET_CLASS (panel_applet_parent_class)->focus (widget, dir);	if (!ret && !previous_focus_child) {		if (!gtk_widget_has_focus (widget))  {			/*			 * Applet does not have a widget which can focus so set			 * the focus on the applet unless it already had focus			 * because it had a tooltip.			 */ 			gtk_widget_set_can_focus (widget, TRUE);			gtk_widget_grab_focus (widget);			gtk_widget_set_can_focus (widget, FALSE);			ret = TRUE;		}	}	return ret;}

static voidunrealize (GtkWidget *widget){    CajaDesktopWindow *window;	CajaDesktopWindowDetails *details;    GdkWindow *root_window;    window = CAJA_DESKTOP_WINDOW (widget);	details = window->details;    root_window = gdk_screen_get_root_window (                      gtk_window_get_screen (GTK_WINDOW (window)));    gdk_property_delete (root_window,                         gdk_atom_intern ("CAJA_DESKTOP_WINDOW_ID", TRUE));	if (details->size_changed_id != 0) {		g_signal_handler_disconnect (gtk_window_get_screen (GTK_WINDOW (window)),					     details->size_changed_id);		details->size_changed_id = 0;	}    GTK_WIDGET_CLASS (caja_desktop_window_parent_class)->unrealize (widget);}

static voidgt_browse_header_bar_class_init(GtBrowseHeaderBarClass* klass){    GObjectClass* object_class = G_OBJECT_CLASS(klass);    object_class->finalize = finalize;    object_class->get_property = get_property;    object_class->set_property = set_property;    props[PROP_CHANNELS_VIEW] = g_param_spec_object("channels-view",                                                    "Channels View",                                                    "Channels View",                                                    GT_TYPE_CHANNELS_VIEW,                                                    G_PARAM_READWRITE);    props[PROP_GAMES_VIEW] = g_param_spec_object("games-view",                                                 "Games View",                                                 "Games View",                                                 GT_TYPE_GAMES_VIEW,                                                 G_PARAM_READWRITE);    props[PROP_FAVOURITES_VIEW] = g_param_spec_object("favourites-view",                                                      "Favourites View",                                                      "Favourites View",                                                      GT_TYPE_FAVOURITES_VIEW,                                                      G_PARAM_READWRITE);    g_object_class_install_properties(object_class,                                      NUM_PROPS,                                      props);    gtk_widget_class_set_template_from_resource(GTK_WIDGET_CLASS(klass),                                                 "/com/gnome-twitch/ui/gt-browse-header-bar.ui");    gtk_widget_class_bind_template_child_private(GTK_WIDGET_CLASS(klass), GtBrowseHeaderBar, nav_buttons_stack);    gtk_widget_class_bind_template_child_private(GTK_WIDGET_CLASS(klass), GtBrowseHeaderBar, nav_buttons_revealer);    gtk_widget_class_bind_template_child_private(GTK_WIDGET_CLASS(klass), GtBrowseHeaderBar, search_button);    gtk_widget_class_bind_template_child_private(GTK_WIDGET_CLASS(klass), GtBrowseHeaderBar, refresh_button);    gtk_widget_class_bind_template_child_private(GTK_WIDGET_CLASS(klass), GtBrowseHeaderBar, refresh_revealer);    gtk_widget_class_bind_template_child_private(GTK_WIDGET_CLASS(klass), GtBrowseHeaderBar, search_revealer);}

static voidgtk_image_menu_item_size_allocate (GtkWidget     *widget,                                   GtkAllocation *allocation){    GtkImageMenuItem *image_menu_item = GTK_IMAGE_MENU_ITEM (widget);    GtkImageMenuItemPrivate *priv = image_menu_item->priv;    GtkAllocation widget_allocation;    GtkPackDirection pack_dir;    GtkWidget *parent;    parent = gtk_widget_get_parent (widget);    if (GTK_IS_MENU_BAR (parent))        pack_dir = gtk_menu_bar_get_child_pack_direction (GTK_MENU_BAR (parent));    else        pack_dir = GTK_PACK_DIRECTION_LTR;    GTK_WIDGET_CLASS (gtk_image_menu_item_parent_class)->size_allocate (widget, allocation);    if (priv->image && gtk_widget_get_visible (priv->image))    {        gint x, y, offset;        GtkStyleContext *context;        GtkStateFlags state;        GtkBorder padding;        GtkRequisition child_requisition;        GtkAllocation child_allocation;        guint horizontal_padding, toggle_spacing;        gint toggle_size;        toggle_size = GTK_MENU_ITEM (image_menu_item)->priv->toggle_size;        gtk_widget_style_get (widget,                              "horizontal-padding", &horizontal_padding,                              "toggle-spacing", &toggle_spacing,                              NULL);        /* Man this is lame hardcoding action, but I can't         * come up with a solution that's really better.         */        gtk_widget_get_preferred_size (priv->image, &child_requisition, NULL);        gtk_widget_get_allocation (widget, &widget_allocation);        context = gtk_widget_get_style_context (widget);        state = gtk_widget_get_state_flags (widget);        gtk_style_context_get_padding (context, state, &padding);        offset = gtk_container_get_border_width (GTK_CONTAINER (image_menu_item));        if (pack_dir == GTK_PACK_DIRECTION_LTR ||                pack_dir == GTK_PACK_DIRECTION_RTL)        {            if ((gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR) ==                    (pack_dir == GTK_PACK_DIRECTION_LTR))                x = offset + horizontal_padding + padding.left +                    (toggle_size - toggle_spacing - child_requisition.width) / 2;            else                x = widget_allocation.width - offset - horizontal_padding - padding.right -                    toggle_size + toggle_spacing +                    (toggle_size - toggle_spacing - child_requisition.width) / 2;            y = (widget_allocation.height - child_requisition.height) / 2;        }        else        {            if ((gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR) ==                    (pack_dir == GTK_PACK_DIRECTION_TTB))                y = offset + horizontal_padding + padding.top +                    (toggle_size - toggle_spacing - child_requisition.height) / 2;            else                y = widget_allocation.height - offset - horizontal_padding - padding.bottom -                    toggle_size + toggle_spacing +                    (toggle_size - toggle_spacing - child_requisition.height) / 2;            x = (widget_allocation.width - child_requisition.width) / 2;        }        child_allocation.width = child_requisition.width;        child_allocation.height = child_requisition.height;        child_allocation.x = widget_allocation.x + MAX (x, 0);        child_allocation.y = widget_allocation.y + MAX (y, 0);        gtk_widget_size_allocate (priv->image, &child_allocation);    }}

/* * Standard Gtk+ function */static gint Dw_gtk_viewport_expose (GtkWidget *widget,                                    GdkEventExpose *event){   Dw_gtk_viewport_paint (widget, &(event->area), event);   return GTK_WIDGET_CLASS(parent_class)->expose_event (widget, event);}

/* * Standard Gtk+ function */static void Dw_gtk_viewport_draw (GtkWidget *widget,                                  GdkRectangle *area){   Dw_gtk_viewport_paint (widget, area, NULL);   GTK_WIDGET_CLASS(parent_class)->draw (widget, area);}