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