static void _lib_viewswitcher_view_changed_callback(gpointer instance, dt_view_t *old_view,
dt_view_t *new_view, gpointer user_data)
{
dt_lib_module_t *self = (dt_lib_module_t *)user_data;
dt_lib_viewswitcher_t *d = (dt_lib_viewswitcher_t *)self->data;
const char *name = dt_view_manager_name(darktable.view_manager);
gboolean found = FALSE;
for(GList *iter = d->labels; iter; iter = g_list_next(iter))
{
GtkWidget *label = GTK_WIDGET(iter->data);
if(!g_strcmp0(g_object_get_data(G_OBJECT(label), "view-label"), name))
{
gtk_widget_set_state_flags(label, GTK_STATE_FLAG_SELECTED, TRUE);
found = TRUE;
}
else
gtk_widget_set_state_flags(label, GTK_STATE_FLAG_NORMAL, TRUE);
}
g_signal_handlers_block_by_func(d->dropdown, _dropdown_changed, d);
if(found)
{
gtk_combo_box_set_active(GTK_COMBO_BOX(d->dropdown), 0);
gtk_widget_set_state_flags(d->dropdown, GTK_STATE_FLAG_NORMAL, TRUE);
}
else
{
GtkTreeModel *model = gtk_combo_box_get_model(GTK_COMBO_BOX(d->dropdown));
GtkTreeIter iter;
uint32_t index = 0;
if(gtk_tree_model_get_iter_first(model, &iter) == TRUE) do
{
gchar *str;
gtk_tree_model_get(model, &iter, TEXT_COLUMN, &str, -1);
if(!g_strcmp0(str, name))
{
gtk_combo_box_set_active(GTK_COMBO_BOX(d->dropdown), index);
gtk_widget_set_state_flags(d->dropdown, GTK_STATE_FLAG_SELECTED, TRUE);
break;
}
g_free(str);
index++;
} while(gtk_tree_model_iter_next(model, &iter) == TRUE);
}
g_signal_handlers_unblock_by_func(d->dropdown, _dropdown_changed, d);
}
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;
}
static void
gtk_check_button_update_node_state (GtkWidget *widget)
{
GtkCheckButtonPrivate *priv = gtk_check_button_get_instance_private (GTK_CHECK_BUTTON (widget));
GtkCssImageBuiltinType image_type;
GtkStateFlags state;
if (!priv->indicator_widget)
return;
state = gtk_widget_get_state_flags (widget);
/* XXX: This is somewhat awkward here, but there's no better
* way to update the icon
*/
if (state & GTK_STATE_FLAG_CHECKED)
image_type = GTK_IS_RADIO_BUTTON (widget) ? GTK_CSS_IMAGE_BUILTIN_OPTION : GTK_CSS_IMAGE_BUILTIN_CHECK;
else if (state & GTK_STATE_FLAG_INCONSISTENT)
image_type = GTK_IS_RADIO_BUTTON (widget) ? GTK_CSS_IMAGE_BUILTIN_OPTION_INCONSISTENT : GTK_CSS_IMAGE_BUILTIN_CHECK_INCONSISTENT;
else
image_type = GTK_CSS_IMAGE_BUILTIN_NONE;
gtk_icon_set_image (GTK_ICON (priv->indicator_widget), image_type);
gtk_widget_set_state_flags (priv->indicator_widget, state, TRUE);
}
static gboolean
swatch_key_press (GtkWidget *widget,
GdkEventKey *event)
{
GtkColorSwatch *swatch = GTK_COLOR_SWATCH (widget);
if (event->keyval == GDK_KEY_space ||
event->keyval == GDK_KEY_Return ||
event->keyval == GDK_KEY_ISO_Enter||
event->keyval == GDK_KEY_KP_Enter ||
event->keyval == GDK_KEY_KP_Space)
{
if (swatch->priv->has_color &&
swatch->priv->selectable &&
(gtk_widget_get_state_flags (widget) & GTK_STATE_FLAG_SELECTED) == 0)
gtk_widget_set_state_flags (widget, GTK_STATE_FLAG_SELECTED, FALSE);
else
g_signal_emit (swatch, signals[ACTIVATE], 0);
return TRUE;
}
if (GTK_WIDGET_CLASS (gtk_color_swatch_parent_class)->key_press_event (widget, event))
return TRUE;
return FALSE;
}
/**
* 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_enter_notify (GtkWidget *widget,
GdkEventCrossing *event)
{
gtk_widget_set_state_flags (widget, GTK_STATE_FLAG_PRELIGHT, FALSE);
return FALSE;
}
/**
* Depending on whether the window is maximized the task title is shown
* or hidden.
*/
static void on_state_changed (WnckWindow *window,
WnckWindowState changed_mask,
WnckWindowState new_state,
TaskTitle *title)
{
TaskTitlePrivate *priv = title->priv;
g_return_if_fail (TASK_IS_TITLE (title));
g_return_if_fail (WNCK_IS_WINDOW (window));
if (priv->window != window)
return;
if (wnck_window_is_maximized (window)) {
gtk_widget_set_state_flags (GTK_WIDGET (title), GTK_STATE_FLAG_ACTIVE, TRUE);
gtk_widget_show (priv->grid);
} else {
gtk_widget_set_state_flags (GTK_WIDGET (title), GTK_STATE_FLAG_NORMAL, TRUE);
gtk_widget_hide (priv->grid);
}
}
static void _lib_viewswitcher_leave_notify_callback(GtkWidget *w, GdkEventCrossing *e, gpointer user_data)
{
GtkLabel *l = (GtkLabel *)user_data;
/* if not active view lets set default */
if(strcmp(g_object_get_data(G_OBJECT(w), "view-label"), dt_view_manager_name(darktable.view_manager)))
{
gtk_widget_set_state_flags(GTK_WIDGET(l), GTK_STATE_FLAG_NORMAL, TRUE);
}
}
void next_view(GObject *object, gpointer user_data)
{
GList *l = chrome->views;
struct _view *old_view = chrome->selected_view;
for (; l; l = l->next) {
struct _view *view = l->data;
if (view == chrome->selected_view) {
if (!l->next)
chrome->selected_view = chrome->views->data;
else
chrome->selected_view = l->next->data;
break;
}
}
gtk_widget_set_state_flags(old_view->tree_view, GTK_STATE_FLAG_INSENSITIVE, TRUE);
gtk_widget_set_state_flags(chrome->selected_view->tree_view, GTK_STATE_FLAG_NORMAL, TRUE);
gtk_widget_grab_focus(chrome->selected_view->tree_view);
}
static gboolean on_enter_notify (GtkWidget *widget,
GdkEventCrossing *event,
TaskTitle *title)
{
g_return_val_if_fail (TASK_IS_TITLE (title), FALSE);
title->priv->mouse_in_close_button = TRUE;
gtk_widget_set_state_flags(widget, GTK_STATE_PRELIGHT, FALSE);
gtk_widget_queue_draw (widget);
return FALSE;
}
static gboolean anaconda_disk_overview_focus_changed(GtkWidget *widget, GdkEventFocus *event, gpointer user_data) {
GtkStateFlags new_state;
new_state = gtk_widget_get_state_flags(widget) & ~GTK_STATE_FOCUSED;
if (event->in)
new_state |= GTK_STATE_FOCUSED;
gtk_widget_set_state_flags(widget, new_state, TRUE);
return FALSE;
}
static gboolean
swatch_enter_notify (GtkWidget *widget,
GdkEventCrossing *event)
{
GtkColorSwatch *swatch = GTK_COLOR_SWATCH (widget);
swatch->priv->contains_pointer = TRUE;
gtk_widget_set_state_flags (widget, GTK_STATE_FLAG_PRELIGHT, FALSE);
return FALSE;
}
static void
lyric_show_viewport_update_current_widget(LyricShowViewport *lsv)
{
if((!lsv->priv->is_pressed) && lsv->priv->current_widget)
{
GtkAllocation alc0,alc1;
const gchar *color_string = "blue";
#if GTK_CHECK_VERSION(3,2,0)
GdkRGBA color = {0};
gdk_rgba_parse(&color,color_string);
#else
GdkColor color = {0};
gdk_color_parse(color_string,&color);
#endif
if(lsv->priv->pre_widget &&
GTK_IS_WIDGET(lsv->priv->pre_widget) &&
lsv->priv->current_widget !=lsv->priv->pre_widget)
{
#if GTK_CHECK_VERSION(3,2,0)
gtk_widget_override_color(lsv->priv->pre_widget,GTK_STATE_FLAG_ACTIVE,NULL);
gtk_widget_set_state_flags(lsv->priv->pre_widget,GTK_STATE_FLAG_ACTIVE,FALSE);
#else
gtk_widget_modify_fg(lsv->priv->pre_widget,GTK_STATE_ACTIVE,NULL);
gtk_widget_set_state(lsv->priv->pre_widget,GTK_STATE_NORMAL);
#endif
}
#if GTK_CHECK_VERSION(3,2,0)
gtk_widget_override_color(lsv->priv->current_widget,GTK_STATE_FLAG_ACTIVE,&color);
gtk_widget_set_state_flags(lsv->priv->current_widget,GTK_STATE_FLAG_ACTIVE,FALSE);
#else
gtk_widget_modify_fg(lsv->priv->current_widget,GTK_STATE_ACTIVE,&color);
gtk_widget_set_state(lsv->priv->current_widget,GTK_STATE_ACTIVE);
#endif
gtk_widget_get_allocation(lsv->priv->current_widget,&alc0);
gtk_widget_get_allocation(lsv->priv->lyricbox,&alc1);
lsv->priv->pos = (alc0.y - alc1.y)+alc0.height/2.0;
gtk_widget_queue_resize(GTK_WIDGET(lsv));
}
}
static void
gtk_text_handle_set_state (GtkTextHandle *handle,
gint pos,
GtkStateFlags state)
{
GtkTextHandlePrivate *priv = handle->priv;
if (!priv->windows[pos].widget)
return;
gtk_widget_set_state_flags (priv->windows[pos].widget, state, FALSE);
gtk_widget_queue_draw (priv->windows[pos].widget);
}
static gboolean
gtk_switch_enter (GtkWidget *widget,
GdkEventCrossing *event)
{
GtkSwitchPrivate *priv = GTK_SWITCH (widget)->priv;
if (event->window == priv->event_window)
{
priv->in_switch = TRUE;
gtk_widget_set_state_flags (widget, GTK_STATE_FLAG_PRELIGHT, FALSE);
}
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 accessx_status_applet_notify_xkb_device(AccessxStatusApplet* sapplet, XkbExtensionDeviceNotifyEvent* event)
{
if (event->reason == XkbXI_IndicatorStateMask)
{
if (event->led_state &= ALT_GRAPH_LED_MASK)
{
gtk_widget_set_sensitive(sapplet->alt_graph_indicator, TRUE);
gtk_widget_set_state_flags (sapplet->alt_graph_indicator, GTK_STATE_FLAG_NORMAL, TRUE);
}
else
{
gtk_widget_set_sensitive(sapplet->alt_graph_indicator, FALSE);
}
}
}
GtkWidget *
task_title_new (WindowPickerApplet *windowPickerApplet)
{
TaskTitle *title = g_object_new (TASK_TYPE_TITLE,
"border-width", 0,
"name", "tasklist-button",
"visible-window", FALSE,
NULL);
title->priv->windowPickerApplet = windowPickerApplet;
if (window_picker_applet_get_show_home_title (title->priv->windowPickerApplet)) {
gtk_widget_set_state_flags (GTK_WIDGET (title), GTK_STATE_FLAG_ACTIVE, TRUE);
} else {
gtk_widget_hide (title->priv->grid);
}
return GTK_WIDGET (title);
}
static gboolean
swatch_primary_action (GtkColorSwatch *swatch)
{
GtkWidget *widget = (GtkWidget *)swatch;
GtkStateFlags flags;
flags = gtk_widget_get_state_flags (widget);
if (!swatch->priv->has_color)
{
g_signal_emit (swatch, signals[ACTIVATE], 0);
return TRUE;
}
else if (swatch->priv->selectable &&
(flags & GTK_STATE_FLAG_SELECTED) == 0)
{
gtk_widget_set_state_flags (widget, GTK_STATE_FLAG_SELECTED, FALSE);
return TRUE;
}
return FALSE;
}
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
gtk_button_update_state (GtkButton *button)
{
GtkButtonPrivate *priv = button->priv;
GtkStateFlags new_state;
gboolean depressed;
if (priv->activate_timeout)
depressed = TRUE;
else
depressed = priv->in_button && priv->button_down;
new_state = gtk_widget_get_state_flags (GTK_WIDGET (button)) &
~(GTK_STATE_FLAG_PRELIGHT | GTK_STATE_FLAG_ACTIVE);
if (priv->in_button)
new_state |= GTK_STATE_FLAG_PRELIGHT;
if (depressed)
new_state |= GTK_STATE_FLAG_ACTIVE;
gtk_widget_set_state_flags (GTK_WIDGET (button), new_state, TRUE);
}
static GtkWidget *_lib_viewswitcher_create_label(dt_view_t *v)
{
GtkWidget *eb = gtk_event_box_new();
GtkWidget *b = gtk_label_new(v->name(v));
gtk_container_add(GTK_CONTAINER(eb), b);
/*setup label*/
gtk_widget_set_halign(b, GTK_ALIGN_START);
g_object_set_data(G_OBJECT(b), "view-label", (gchar *)v->name(v));
g_object_set_data(G_OBJECT(eb), "view-label", (gchar *)v->name(v));
gtk_widget_set_name(b, "view_label");
gtk_widget_set_state_flags(b, GTK_STATE_FLAG_NORMAL, TRUE);
/* connect button press handler */
g_signal_connect(G_OBJECT(eb), "button-press-event", G_CALLBACK(_lib_viewswitcher_button_press_callback),
GINT_TO_POINTER(v->view(v)));
/* set enter/leave notify events and connect signals */
gtk_widget_add_events(GTK_WIDGET(eb), GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK);
g_signal_connect(G_OBJECT(eb), "enter-notify-event", G_CALLBACK(_lib_viewswitcher_enter_notify_callback), b);
g_signal_connect(G_OBJECT(eb), "leave-notify-event", G_CALLBACK(_lib_viewswitcher_leave_notify_callback), b);
return eb;
}
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);
}
static GtkIconSet* accessx_status_applet_altgraph_icon_set(AccessxStatusApplet* sapplet, GtkWidget* widget)
{
GtkIconSet* icon_set = gtk_icon_set_new();
gint i;
GtkStateType states[3] = {GTK_STATE_NORMAL, GTK_STATE_INSENSITIVE, GTK_STATE_SELECTED};
GtkStyle* style = gtk_widget_get_style(widget);
GdkPixbuf* icon_base;
gtk_widget_set_sensitive(widget, TRUE);
for (i = 0; i < 3; ++i)
{
int alpha;
GdkColor* fg;
GdkColor* bg;
GtkIconSource* source = gtk_icon_source_new();
GdkPixbuf* pixbuf;
GdkPixbuf* glyph_pixbuf;
gboolean wildcarded = FALSE;
fg = &style->text[states[i]];
bg = &style->white;
switch (states[i])
{
case GTK_STATE_NORMAL:
alpha = 255;
gtk_widget_set_sensitive(widget, TRUE);
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_widget_set_state_flags (widget, GTK_STATE_FLAG_NORMAL, TRUE);
#else
gtk_widget_set_state(widget, GTK_STATE_NORMAL);
#endif
break;
case GTK_STATE_SELECTED:
/* FIXME: should use text/base here, for selected ? */
fg = &style->white;
bg = &style->black;
alpha = 255;
gtk_widget_set_sensitive(widget, TRUE);
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_widget_set_state_flags (widget, GTK_STATE_FLAG_SELECTED, TRUE);
#else
gtk_widget_set_state(widget, GTK_STATE_SELECTED);
#endif
break;
case GTK_STATE_INSENSITIVE:
default:
alpha = 63;
gtk_widget_set_sensitive(widget, FALSE);
wildcarded = TRUE;
break;
}
icon_base = gtk_widget_render_icon(widget, ACCESSX_BASE_ICON, icon_size_spec, NULL);
pixbuf = gdk_pixbuf_copy(icon_base);
g_object_unref(icon_base);
/*
* should be N_("ae"));
* need en_ locale for this.
*/
/*
* Translators: substitute an easily-recognized single glyph
* from Level 2, i.e. an AltGraph character from a common keyboard
* in your locale.
*/
glyph_pixbuf = accessx_status_applet_get_glyph_pixbuf(sapplet, widget, pixbuf, fg, bg, ("æ"));
gdk_pixbuf_composite(glyph_pixbuf, pixbuf, 0, 0, gdk_pixbuf_get_width(glyph_pixbuf), gdk_pixbuf_get_height(glyph_pixbuf), 0., 0., 1.0, 1.0, GDK_INTERP_NEAREST, alpha);
g_object_unref(glyph_pixbuf);
gtk_icon_source_set_pixbuf(source, pixbuf);
gtk_icon_source_set_state(source, states[i]);
gtk_icon_source_set_state_wildcarded(source, wildcarded);
gtk_icon_set_add_source(icon_set, source);
gtk_icon_source_free(source);
}
/* we mucked about with the box's state to create the icons; restore it to normal */
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_widget_set_state_flags (widget, GTK_STATE_FLAG_NORMAL, TRUE);
#else
gtk_widget_set_state(widget, GTK_STATE_NORMAL);
#endif
gtk_widget_set_sensitive(widget, TRUE);
return icon_set;
}
static void accessx_status_applet_update(AccessxStatusApplet* sapplet, AccessxStatusNotifyType notify_type, XkbEvent* event)
{
GdkWindow* window;
gint i;
window = gtk_widget_get_window(GTK_WIDGET(sapplet->applet));
if (notify_type & ACCESSX_STATUS_MODIFIERS)
{
unsigned int locked_mods = 0, latched_mods = 0;
if (event != NULL)
{
locked_mods = event->state.locked_mods;
latched_mods = event->state.latched_mods;
}
else if (sapplet->applet && window)
{
XkbStateRec state;
XkbGetState(GDK_WINDOW_XDISPLAY(window), XkbUseCoreKbd, &state);
locked_mods = state.locked_mods;
latched_mods = state.latched_mods;
}
/* determine which modifiers are locked, and set state accordingly */
for (i = 0; i < G_N_ELEMENTS(modifiers); ++i)
{
if (modifiers[i].indicator != NULL && modifiers[i].mask)
{
if (locked_mods & modifiers[i].mask)
{
gtk_widget_set_sensitive(modifiers[i].indicator, TRUE);
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_widget_set_state_flags (modifiers[i].indicator, GTK_STATE_FLAG_SELECTED, TRUE);
#else
gtk_widget_set_state(modifiers[i].indicator, GTK_STATE_SELECTED);
#endif
}
else if (latched_mods & modifiers[i].mask)
{
gtk_widget_set_sensitive(modifiers[i].indicator, TRUE);
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_widget_set_state_flags (modifiers[i].indicator, GTK_STATE_FLAG_NORMAL, TRUE);
#else
gtk_widget_set_state(modifiers[i].indicator, GTK_STATE_NORMAL);
#endif
}
else
{
gtk_widget_set_sensitive(modifiers[i].indicator, FALSE);
}
}
}
}
if ((notify_type & ACCESSX_STATUS_SLOWKEYS) && (event != NULL))
{
GdkPixbuf* pixbuf = accessx_status_applet_slowkeys_image(sapplet, &event->accessx);
gtk_image_set_from_pixbuf(GTK_IMAGE(sapplet->slowfoo), pixbuf);
g_object_unref(pixbuf);
}
if ((notify_type & ACCESSX_STATUS_BOUNCEKEYS) && (event != NULL))
{
GdkPixbuf* pixbuf = accessx_status_applet_bouncekeys_image(sapplet, &event->accessx);
gtk_image_set_from_pixbuf(GTK_IMAGE(sapplet->bouncefoo), pixbuf);
g_object_unref(pixbuf);
}
if (notify_type & ACCESSX_STATUS_MOUSEKEYS)
{
GdkPixbuf* pixbuf = accessx_status_applet_mousekeys_image(sapplet, &event->state);
gtk_image_set_from_pixbuf(GTK_IMAGE(sapplet->mousefoo), pixbuf);
g_object_unref(pixbuf);
}
if (notify_type & ACCESSX_STATUS_ENABLED)
{
/* Update the visibility of widgets in the box */
/* XkbMouseKeysMask | XkbStickyKeysMask | XkbSlowKeysMask | XkbBounceKeysMask */
XkbGetControls(GDK_WINDOW_XDISPLAY(window), XkbAllControlsMask, sapplet->xkb);
if (!(sapplet->xkb->ctrls->enabled_ctrls & (XkbMouseKeysMask | XkbStickyKeysMask | XkbSlowKeysMask | XkbBounceKeysMask)))
{
gtk_widget_show(sapplet->idlefoo);
}
else
{
gtk_widget_hide(sapplet->idlefoo);
}
if (sapplet->xkb->ctrls->enabled_ctrls & XkbMouseKeysMask)
{
gtk_widget_show(sapplet->mousefoo);
}
else
{
gtk_widget_hide(sapplet->mousefoo);
}
if (sapplet->xkb->ctrls->enabled_ctrls & XkbStickyKeysMask)
{
gtk_widget_show(sapplet->stickyfoo);
}
else
{
gtk_widget_hide(sapplet->stickyfoo);
}
if (sapplet->xkb->ctrls->enabled_ctrls & XkbSlowKeysMask)
{
gtk_widget_show(sapplet->slowfoo);
}
else
{
gtk_widget_hide(sapplet->slowfoo);
}
if (sapplet->xkb->ctrls->enabled_ctrls & XkbBounceKeysMask)
{
gtk_widget_show(sapplet->bouncefoo);
}
else
{
gtk_widget_hide(sapplet->bouncefoo);
}
}
return;
}
CodeAssistWidget *
code_assist_widget_new()
{
CodeAssistWidget *_code_assist = g_malloc (sizeof (CodeAssistWidget));
if (!_code_assist)
return NULL;
_code_assist->list_view = gtk_tree_view_new ();
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (_code_assist->list_view), FALSE);
GtkTreeSelection *tree_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (_code_assist->list_view));
g_signal_connect (G_OBJECT (tree_selection), "changed",
G_CALLBACK (_code_assist_tree_selection_changed),
_code_assist);
_code_assist->list_store = gtk_list_store_new (ASSIST_COL_TOTAL, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_POINTER);
GtkCellRenderer *renderer = gtk_cell_renderer_pixbuf_new ();
GtkTreeViewColumn *column = gtk_tree_view_column_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column,
renderer, "pixbuf", ASSIST_COL_PIXBUF , NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_add_attribute (column, renderer, "text", ASSIST_COL_DEF);
gtk_tree_view_append_column (GTK_TREE_VIEW (_code_assist->list_view), column);
gtk_tree_view_set_model (GTK_TREE_VIEW (_code_assist->list_view),
GTK_TREE_MODEL (_code_assist->list_store));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (_code_assist->list_view),
TRUE);
_code_assist->scroll_win = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (_code_assist->scroll_win),
GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (_code_assist->scroll_win),
GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS);
gtk_container_add (GTK_CONTAINER (_code_assist->scroll_win),
_code_assist->list_view);
gtk_widget_set_size_request (_code_assist->scroll_win, 300, 200);
_code_assist->text_view = gtk_text_view_new ();
gtk_widget_set_state_flags (_code_assist->text_view,
GTK_STATE_FLAG_INSENSITIVE, FALSE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (_code_assist->text_view),
GTK_WRAP_WORD);
_code_assist->text_scroll_win = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (_code_assist->text_scroll_win),
GTK_SHADOW_IN);
g_object_ref (_code_assist->text_scroll_win);
gtk_widget_set_size_request (_code_assist->text_scroll_win, 300, 200);
gtk_container_add (GTK_CONTAINER (_code_assist->text_scroll_win),
_code_assist->text_view);
_code_assist->parent = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
//gtk_container_add (GTK_CONTAINER (_code_assist->parent),
//_code_assist->scroll_win);
gtk_box_pack_start (GTK_BOX (_code_assist->parent),
_code_assist->scroll_win, FALSE, FALSE, 0);
g_object_ref (_code_assist->parent);
_code_assist->py_var_array_size = 0;
_code_assist->py_var_array = NULL;
return _code_assist;
}
/**
* Hides the task title and resets its contents
*/
static void hide_title(TaskTitle *title) {
gtk_widget_set_state_flags (GTK_WIDGET (title), GTK_STATE_FLAG_NORMAL, TRUE);
gtk_widget_set_tooltip_text (title->priv->button, NULL);
gtk_widget_set_tooltip_text (GTK_WIDGET (title), NULL);
gtk_widget_hide (title->priv->grid);
}
