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);
}
