tile_expose (GtkWidget * widget, GdkEventExpose * event) #endif { /* FIXME: there ought to be a better way to prevent the focus from being rendered. */ gboolean has_focus; gboolean retval; if ((has_focus = gtk_widget_has_focus (widget))) #if GTK_CHECK_VERSION (3, 0, 0) gtk_widget_unset_state_flags (widget, GTK_STATE_FLAG_FOCUSED); #else GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS); #endif #if GTK_CHECK_VERSION (3, 0, 0) retval = (*GTK_WIDGET_CLASS (tile_parent_class)->draw) (widget, cr); #else retval = (*GTK_WIDGET_CLASS (tile_parent_class)->expose_event) (widget, event); #endif if (has_focus) #if GTK_CHECK_VERSION (3, 0, 0) gtk_widget_set_state_flags (widget, GTK_STATE_FLAG_FOCUSED, TRUE); #else GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS); #endif return retval; }
/** * gtk_switch_set_state: * @sw: a #GtkSwitch * @state: the new state * * Sets the underlying state of the #GtkSwitch. * * Normally, this is the same as #GtkSwitch:active, unless the switch * is set up for delayed state changes. This function is typically * called from a #GtkSwitch::state-set signal handler. * * See #GtkSwitch::state-set for details. * * Since: 3.14 */ void gtk_switch_set_state (GtkSwitch *sw, gboolean state) { g_return_if_fail (GTK_IS_SWITCH (sw)); state = state != FALSE; if (sw->priv->state == state) return; sw->priv->state = state; /* This will be a no-op if we're switching the state in response * to a UI change. We're setting active anyway, to catch 'spontaneous' * state changes. */ gtk_switch_set_active (sw, state); if (state) gtk_widget_set_state_flags (GTK_WIDGET (sw), GTK_STATE_FLAG_CHECKED, FALSE); else gtk_widget_unset_state_flags (GTK_WIDGET (sw), GTK_STATE_FLAG_CHECKED); g_object_notify (G_OBJECT (sw), "state"); }
static gboolean swatch_leave_notify (GtkWidget *widget, GdkEventCrossing *event) { gtk_widget_unset_state_flags (widget, GTK_STATE_FLAG_PRELIGHT); return FALSE; }
static void panel_menu_button_menu_deactivated (PanelMenuButton *button) { panel_toplevel_pop_autohide_disabler (button->priv->toplevel); gtk_widget_unset_state_flags (GTK_WIDGET (button), GTK_STATE_FLAG_PRELIGHT); button_widget_set_ignore_leave (BUTTON_WIDGET (button), FALSE); }
static gboolean on_leave_notify (GtkWidget *widget, GdkEventCrossing *event, TaskTitle *title) { g_return_val_if_fail (TASK_IS_TITLE (title), FALSE); title->priv->mouse_in_close_button = FALSE; gtk_widget_unset_state_flags(widget, GTK_STATE_PRELIGHT); gtk_widget_queue_draw (widget); return FALSE; }
static gboolean swatch_leave_notify (GtkWidget *widget, GdkEventCrossing *event) { GtkColorSwatch *swatch = GTK_COLOR_SWATCH (widget); swatch->priv->contains_pointer = FALSE; gtk_widget_unset_state_flags (widget, GTK_STATE_FLAG_PRELIGHT); return FALSE; }
static void panel_menu_button_menu_deactivated (PanelMenuButton *button) { panel_toplevel_pop_autohide_disabler (button->priv->toplevel); #if GTK_CHECK_VERSION (3, 0, 0) gtk_widget_unset_state_flags (GTK_WIDGET (button), GTK_STATE_FLAG_PRELIGHT); #else GTK_BUTTON (button)->in_button = FALSE; #endif button_widget_set_ignore_leave (BUTTON_WIDGET (button), FALSE); }
static void gtk_text_handle_unset_state (GtkTextHandle *handle, gint pos, GtkStateFlags state) { GtkTextHandlePrivate *priv = handle->priv; if (!priv->windows[pos].widget) return; gtk_widget_unset_state_flags (priv->windows[pos].widget, state); gtk_widget_queue_draw (priv->windows[pos].widget); }
static gboolean flat_button_real_draw (GtkWidget* base, cairo_t* c) { FlatButton * self; gboolean result = FALSE; cairo_t* _tmp0_; gboolean _tmp1_ = FALSE; self = (FlatButton*) base; g_return_val_if_fail (c != NULL, FALSE); gtk_widget_unset_state_flags ((GtkWidget*) self, GTK_STATE_FLAG_PRELIGHT); _tmp0_ = c; _tmp1_ = GTK_WIDGET_CLASS (flat_button_parent_class)->draw ((GtkWidget*) G_TYPE_CHECK_INSTANCE_CAST (self, GTK_TYPE_BUTTON, GtkButton), _tmp0_); result = _tmp1_; return result; }
static gboolean gtk_switch_leave (GtkWidget *widget, GdkEventCrossing *event) { GtkSwitchPrivate *priv = GTK_SWITCH (widget)->priv; if (event->window == priv->event_window) { priv->in_switch = FALSE; gtk_widget_unset_state_flags (widget, GTK_STATE_FLAG_PRELIGHT); } return FALSE; }
/** * @brief * @param ui The GstSwitchUI instance. * @param key * @memberof GstSwitchUI */ static void gst_switch_ui_select_preview (GstSwitchUI * ui, guint key) { GList *view = NULL, *selected = NULL; GtkWidget *previous = NULL; GST_SWITCH_UI_LOCK_SELECT (ui); view = gtk_container_get_children (GTK_CONTAINER (ui->preview_box)); if (ui->selected == NULL) { if (view) switch (key) { case GDK_KEY_Up: selected = g_list_last (view); break; case GDK_KEY_Down: selected = view; break; } } else { for (; view; view = g_list_next (view)) { if (GTK_WIDGET (view->data) == ui->selected) { selected = view; break; } } if (selected) { previous = GTK_WIDGET (selected->data); switch (key) { case GDK_KEY_Up: selected = g_list_previous (selected); break; case GDK_KEY_Down: selected = g_list_next (selected); break; } } } if (selected) { ui->selected = GTK_WIDGET (selected->data); } if (ui->selected) { if (previous) { gtk_widget_unset_state_flags (previous, GTK_STATE_FLAG_SELECTED); } gtk_widget_set_state_flags (ui->selected, GTK_STATE_FLAG_SELECTED, TRUE); //INFO ("select: %p, %p", previous, ui->selected); } GST_SWITCH_UI_UNLOCK_SELECT (ui); }
static void fcombo_arrow_format (GnmFilterCombo *fcombo, GtkWidget *arrow) { if (gtk_widget_get_parent (arrow)) { char *desc = NULL; if (NULL != fcombo->cond) { } if (desc) { gtk_widget_set_tooltip_text (gtk_widget_get_parent (arrow), desc); g_free (desc); } } gtk_arrow_set (GTK_ARROW (arrow), fcombo->cond != NULL ? GTK_ARROW_RIGHT : GTK_ARROW_DOWN, GTK_SHADOW_IN); if (fcombo->cond) gtk_widget_set_state_flags (arrow, GTK_STATE_FLAG_ACTIVE, FALSE); else gtk_widget_unset_state_flags (arrow, GTK_STATE_FLAG_ACTIVE); }
/** * gtk_switch_set_active: * @sw: a #GtkSwitch * @is_active: %TRUE if @sw should be active, and %FALSE otherwise * * Changes the state of @sw to the desired one. * * Since: 3.0 */ void gtk_switch_set_active (GtkSwitch *sw, gboolean is_active) { GtkSwitchPrivate *priv; g_return_if_fail (GTK_IS_SWITCH (sw)); is_active = !!is_active; priv = sw->priv; if (priv->is_active != is_active) { AtkObject *accessible; priv->is_active = is_active; g_object_notify_by_pspec (G_OBJECT (sw), switch_props[PROP_ACTIVE]); if (priv->action_helper) gtk_action_helper_activate (priv->action_helper); G_GNUC_BEGIN_IGNORE_DEPRECATIONS; if (priv->action) gtk_action_activate (priv->action); G_GNUC_END_IGNORE_DEPRECATIONS; accessible = gtk_widget_get_accessible (GTK_WIDGET (sw)); atk_object_notify_state_change (accessible, ATK_STATE_CHECKED, priv->is_active); if (priv->is_active) gtk_widget_set_state_flags (GTK_WIDGET (sw), GTK_STATE_FLAG_ACTIVE, FALSE); else gtk_widget_unset_state_flags (GTK_WIDGET (sw), GTK_STATE_FLAG_ACTIVE); gtk_widget_queue_draw (GTK_WIDGET (sw)); } }
static void anjuta_tabber_render_tab (GtkWidget* widget, GtkWidget* tab, cairo_t* cr, gboolean current, GtkRegionFlags region_flags) { AnjutaTabber* tabber = ANJUTA_TABBER (widget); GtkAllocation alloc; GtkAllocation widget_alloc; gint focus_width; gint tab_curvature; gint tab_overlap; gint tab_begin; gint tab_end; gint xpadding; gint ypadding; GtkStyleContext* context = gtk_widget_get_style_context (widget); if (current) gtk_widget_set_state_flags (tab, GTK_STATE_FLAG_ACTIVE, TRUE); else gtk_widget_unset_state_flags (tab, GTK_STATE_FLAG_ACTIVE); gtk_widget_style_get (widget, "focus-line-width", &focus_width, "tab-curvature", &tab_curvature, "tab-overlap", &tab_overlap, NULL); /* Get border/padding for tab */ gtk_style_context_save (context); gtk_style_context_add_class (context, GTK_STYLE_CLASS_NOTEBOOK); gtk_style_context_add_region (context, GTK_STYLE_REGION_TAB, region_flags); if (current) gtk_style_context_set_state (context, GTK_STATE_FLAG_ACTIVE); if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR) gtk_style_context_set_junction_sides (context, GTK_JUNCTION_CORNER_TOPLEFT); else gtk_style_context_set_junction_sides (context, GTK_JUNCTION_CORNER_TOPRIGHT); gtk_widget_get_allocation (widget, &widget_alloc); gtk_widget_get_allocation (tab, &alloc); xpadding = focus_width + tabber->priv->tab_hborder; ypadding = focus_width + tabber->priv->tab_vborder; tab_begin = tab_curvature - tab_overlap; tab_end = tab_curvature - tab_overlap; if (region_flags | GTK_REGION_FIRST) tab_begin += tab_overlap; if (region_flags | GTK_REGION_LAST) tab_end += tab_overlap; alloc.x -= widget_alloc.x; alloc.x -= tab_begin; alloc.x -= xpadding; alloc.y -= widget_alloc.y; alloc.y -= ypadding; alloc.width += 2 * (xpadding) + tab_begin + tab_end; alloc.height += 2 * ypadding; gtk_render_extension (context, cr, alloc.x, alloc.y, alloc.width, alloc.height, GTK_POS_BOTTOM); if (gtk_widget_has_focus (widget) && current) { GtkAllocation allocation; gtk_widget_get_allocation (tab, &allocation); gtk_render_focus (context, cr, allocation.x - focus_width, allocation.y - focus_width, allocation.width + 2 * focus_width, allocation.height + 2 * focus_width); } gtk_style_context_restore (context); }