static void sexy_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 void widget_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 gboolean gtk_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 void gb_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 void contact_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 void gb_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 void gtk_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 void gimp_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 void gtk_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 gboolean matecomponent_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 void mosaic_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 void gimp_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 gboolean on_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 gboolean file_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 void gtk_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 void gtk_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 gboolean athena_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 void ide_editor_perspective_class_init (IdeEditorPerspectiveClass *klass) { GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass); DzlDockBinClass *dock_bin_class = DZL_DOCK_BIN_CLASS (klass); widget_class->destroy = ide_editor_perspective_destroy; widget_class->hierarchy_changed = ide_editor_perspective_hierarchy_changed; widget_class->grab_focus = ide_editor_perspective_grab_focus; container_class->add = ide_editor_perspective_add; dock_bin_class->create_edge = ide_editor_perspective_create_edge; gtk_widget_class_set_template_from_resource (widget_class, "/org/gnome/builder/ui/ide-editor-perspective.ui"); gtk_widget_class_bind_template_child (widget_class, IdeEditorPerspective, grid); gtk_widget_class_bind_template_child (widget_class, IdeEditorPerspective, overlay); gtk_widget_class_bind_template_child (widget_class, IdeEditorPerspective, properties); g_type_ensure (IDE_TYPE_EDITOR_PROPERTIES); g_type_ensure (IDE_TYPE_EDITOR_SIDEBAR); g_type_ensure (IDE_TYPE_LAYOUT_GRID); }
static void gtr_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 void unrealize (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 void clock_map_class_init (ClockMapClass *this_class) { GObjectClass *g_obj_class = G_OBJECT_CLASS (this_class); GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (g_obj_class); g_obj_class->finalize = clock_map_finalize; /* GtkWidget signals */ widget_class->size_allocate = clock_map_size_allocate; widget_class->draw = clock_map_draw; widget_class->get_preferred_width = clock_map_get_preferred_width; widget_class->get_preferred_height = clock_map_get_preferred_height; g_type_class_add_private (this_class, sizeof (ClockMapPrivate)); /** * ClockMap::need-locations * * The map widget emits this signal when it needs to know which * locations to display. * * Returns: the handler should return a (GList *) of (ClockLocation *). * The map widget will not modify this list, so the caller should keep * it alive. */ signals[NEED_LOCATIONS] = g_signal_new ("need-locations", G_TYPE_FROM_CLASS (g_obj_class), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (ClockMapClass, need_locations), NULL, NULL, _clock_marshal_POINTER__VOID, G_TYPE_POINTER, 0); }
static void gt_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 void gis_password_page_class_init (GisPasswordPageClass *klass) { GisPageClass *page_class = GIS_PAGE_CLASS (klass); GObjectClass *object_class = G_OBJECT_CLASS (klass); gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass), "/org/gnome/initial-setup/gis-password-page.ui"); gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass), GisPasswordPage, password_entry); gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass), GisPasswordPage, confirm_entry); gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass), GisPasswordPage, password_strength); gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass), GisPasswordPage, password_explanation); gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass), GisPasswordPage, confirm_explanation); page_class->page_id = PAGE_ID; page_class->locale_changed = gis_password_page_locale_changed; page_class->save_data = gis_password_page_save_data; page_class->shown = gis_password_page_shown; object_class->constructed = gis_password_page_constructed; object_class->dispose = gis_password_page_dispose; }
static void gtk_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); }