static void html_editor_image_dialog_set_height_units (EHTMLEditorImageDialog *dialog) { gint requested; gulong natural; gint height = -1; natural = webkit_dom_html_image_element_get_natural_height ( dialog->priv->image); requested = gtk_spin_button_get_value_as_int ( GTK_SPIN_BUTTON (dialog->priv->height_edit)); switch (gtk_combo_box_get_active ( GTK_COMBO_BOX (dialog->priv->height_units))) { case 0: /* px */ if (gtk_widget_is_sensitive (dialog->priv->height_edit)) { height = requested * natural * 0.01; } else { height = natural; } webkit_dom_element_remove_attribute ( WEBKIT_DOM_ELEMENT (dialog->priv->image), "style"); gtk_widget_set_sensitive (dialog->priv->height_edit, TRUE); break; case 1: /* percent */ if (gtk_widget_is_sensitive (dialog->priv->height_edit)) { height = (((gdouble) requested) / natural) * 100; } else { height = 100; } webkit_dom_element_remove_attribute ( WEBKIT_DOM_ELEMENT (dialog->priv->image), "style"); gtk_widget_set_sensitive (dialog->priv->height_edit, TRUE); break; case 2: /* follow */ webkit_dom_element_set_attribute ( WEBKIT_DOM_ELEMENT (dialog->priv->image), "style", "height: auto;", NULL); gtk_widget_set_sensitive (dialog->priv->height_edit, FALSE); break; } if (height != -1) { gtk_spin_button_set_value ( GTK_SPIN_BUTTON (dialog->priv->height_edit), height); } }
static void eog_zoom_entry_update_sensitivity (EogZoomEntry *entry) { const gboolean current_state = gtk_widget_is_sensitive (entry->priv->value_entry); const gboolean new_state = gtk_widget_is_sensitive (entry->priv->btn_zoom_in) | gtk_widget_is_sensitive (entry->priv->btn_zoom_out); if (current_state != new_state) { gtk_widget_set_sensitive (entry->priv->value_entry, new_state); } }
/**************************************************************** Move item down in queue *****************************************************************/ static void queue_bubble_down(struct worklist_data *ptr) { GtkTreePath *path; GtkTreeViewColumn *col; GtkTreeModel *model; if (!gtk_widget_is_sensitive(ptr->dst_view)) { return; } model = GTK_TREE_MODEL(ptr->dst); gtk_tree_view_get_cursor(GTK_TREE_VIEW(ptr->dst_view), &path, &col); if (path) { GtkTreeIter it, it_next; gtk_tree_model_get_iter(model, &it, path); it_next = it; if (gtk_tree_model_iter_next(model, &it_next)) { gtk_list_store_swap(GTK_LIST_STORE(model), &it, &it_next); gtk_tree_path_next(path); gtk_tree_view_set_cursor(GTK_TREE_VIEW(ptr->dst_view), path, col, FALSE); commit_worklist(ptr); } } gtk_tree_path_free(path); }
static gboolean gdm_extension_list_set_active_extension (GdmExtensionList *widget, GdmLoginExtension *extension) { GtkWidget *button; gboolean was_sensitive; gboolean was_activated; if (!gdm_login_extension_is_visible (extension)) { return FALSE; } was_sensitive = gtk_widget_get_sensitive (GTK_WIDGET (widget)); gtk_widget_set_sensitive (GTK_WIDGET (widget), TRUE); button = GTK_WIDGET (g_object_get_data (G_OBJECT (extension), "gdm-extension-list-button")); was_activated = FALSE; if (gtk_widget_is_sensitive (button)) { if (gtk_widget_activate (button)) { was_activated = TRUE; } } gtk_widget_set_sensitive (GTK_WIDGET (widget), was_sensitive); return was_activated; }
/*! \brief sets the current points to empty array \param curve (MtxCurve *) pointer to curve \param num_points (gint) size of array to create */ gboolean mtx_curve_set_empty_array (MtxCurve *curve, gint num_points) { gint i = 0; MtxCurvePrivate *priv = MTX_CURVE_GET_PRIVATE(curve); g_return_val_if_fail (MTX_IS_CURVE (curve),FALSE); g_object_freeze_notify (G_OBJECT (curve)); if (priv->coords) g_free(priv->coords); priv->coords = g_new0(MtxCurveCoord,num_points); priv->num_points = num_points; priv->highest_x = 0; priv->highest_y = 0; priv->lowest_x = 0; priv->lowest_y = 0; for (i=0;i<num_points;i++) { priv->coords[i].x = 0; priv->coords[i].y = 0; } g_object_thaw_notify (G_OBJECT (curve)); #if GTK_MINOR_VERSION >= 18 if (!gtk_widget_is_sensitive(GTK_WIDGET(curve))) return TRUE; #else if (!GTK_WIDGET_IS_SENSITIVE(GTK_WIDGET(curve))) return TRUE; #endif if (priv->auto_rescale_id == 0) priv->auto_rescale_id = g_timeout_add(1000,(GSourceFunc)auto_rescale,priv); return TRUE; }
/*! \brief sets the current points \param curve (MtxCurve *) pointer to curve \param num_points (gint) new value \param array (MtxCurveCoord*) Array of points */ gboolean mtx_curve_set_coords (MtxCurve *curve, gint num_points, MtxCurveCoord *array) { /* gint i = 0; */ MtxCurvePrivate *priv = MTX_CURVE_GET_PRIVATE(curve); g_return_val_if_fail (MTX_IS_CURVE (curve),FALSE); g_object_freeze_notify (G_OBJECT (curve)); if (priv->coords) g_free(priv->coords); priv->coords = g_memdup(array,(num_points*sizeof(MtxCurveCoord))); priv->num_points = num_points; recalc_extremes(priv); /* for (i=0;i<num_points;i++) printf("new coord %f,%f\n",priv->coords[i].x,priv->coords[i].y); */ g_object_thaw_notify (G_OBJECT (curve)); #if GTK_MINOR_VERSION >= 18 if (!gtk_widget_is_sensitive(GTK_WIDGET(curve))) return TRUE; #else if (!GTK_WIDGET_IS_SENSITIVE(GTK_WIDGET(curve))) return TRUE; #endif if (priv->auto_rescale_id == 0) priv->auto_rescale_id = g_timeout_add(1000,(GSourceFunc)auto_rescale,priv); return TRUE; }
static void toggle_sensitivity_cb (GtkWidget *widget, gpointer data) { GtkWidget *target = (GtkWidget *)data; gtk_widget_set_sensitive (target, !gtk_widget_is_sensitive (target)); }
static void gtk_expander_state_changed (GtkWidget *widget, GtkStateType previous_state) { if (!gtk_widget_is_sensitive (widget)) GTK_EXPANDER (widget)->priv->button_down = FALSE; }
static void cc_timezone_map_size_allocate (GtkWidget *widget, GtkAllocation *allocation) { CcTimezoneMapPrivate *priv = CC_TIMEZONE_MAP (widget)->priv; GdkPixbuf *pixbuf; if (priv->background) g_object_unref (priv->background); if (!gtk_widget_is_sensitive (widget)) pixbuf = priv->orig_background_dim; else pixbuf = priv->orig_background; priv->background = gdk_pixbuf_scale_simple (pixbuf, allocation->width, allocation->height, GDK_INTERP_BILINEAR); if (priv->color_map) g_object_unref (priv->color_map); priv->color_map = gdk_pixbuf_scale_simple (priv->orig_color_map, allocation->width, allocation->height, GDK_INTERP_BILINEAR); priv->visible_map_pixels = gdk_pixbuf_get_pixels (priv->color_map); priv->visible_map_rowstride = gdk_pixbuf_get_rowstride (priv->color_map); GTK_WIDGET_CLASS (cc_timezone_map_parent_class)->size_allocate (widget, allocation); }
/**************************************************************** Source row activated *****************************************************************/ static void src_row_callback(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColumn *col, gpointer data) { struct worklist_data *ptr; GtkTreeModel *src_model, *dst_model; GtkTreeIter src_it, dst_it; gint i, ncols; ptr = data; if (!gtk_widget_is_sensitive(ptr->dst_view)) { return; } src_model = GTK_TREE_MODEL(ptr->src); dst_model = GTK_TREE_MODEL(ptr->dst); gtk_tree_model_get_iter(src_model, &src_it, path); gtk_list_store_append(GTK_LIST_STORE(dst_model), &dst_it); ncols = gtk_tree_model_get_n_columns(src_model); for (i = 0; i < ncols; i++) { GValue value = { 0, }; gtk_tree_model_get_value(src_model, &src_it, i, &value); gtk_list_store_set_value(GTK_LIST_STORE(dst_model), &dst_it, i, &value); } commit_worklist(ptr); }
/* * A variant of gtk_window_activate_default that does not end up reactivating * the widget that [Enter] was pressed in. */ static void cb_activate_default (GtkWindow *window) { GtkWidget *w = gtk_window_get_default_widget (window); if (w && gtk_widget_is_sensitive (w)) gtk_widget_activate (w); }
/*! \brief handles exposure events when the screen is covered and then exposed. Works by copying from a backing pixmap to screen, \param widget (GtkWidget *) pointer to the chart object \param event (GdkEventExpose *) pointer to GDK event datastructure that encodes important info like window dimensions and depth. */ gboolean mtx_stripchart_expose (GtkWidget *widget, GdkEventExpose *event) { MtxStripChart * chart = MTX_STRIPCHART(widget); MtxStripChartPrivate *priv = MTX_STRIPCHART_GET_PRIVATE(chart); cairo_t *cr = NULL; #if GTK_MINOR_VERSION >= 18 if (gtk_widget_is_sensitive(GTK_WIDGET(widget))) #else if (GTK_WIDGET_IS_SENSITIVE(GTK_WIDGET(widget))) #endif { cr = gdk_cairo_create(widget->window); gdk_cairo_set_source_pixmap(cr,priv->bg_pixmap,0,0); cairo_rectangle(cr,event->area.x, event->area.y,event->area.width, event->area.height); cairo_fill(cr); cairo_destroy(cr); } else { cr = gdk_cairo_create(widget->window); gdk_cairo_set_source_pixmap(cr,priv->bg_pixmap,0,0); cairo_rectangle(cr,event->area.x, event->area.y,event->area.width, event->area.height); cairo_fill(cr); cairo_set_source_rgba (cr, 0.3,0.3,0.3,0.5); cairo_paint(cr); /* cairo_rectangle (cr, 0,0,priv->w,priv->h); cairo_fill(cr); */ cairo_destroy(cr); } return FALSE; }
static void script_fu_response (GtkWidget *widget, gint response_id, SFScript *script) { GtkWidget *action_area; action_area = gtk_dialog_get_action_area (GTK_DIALOG (sf_interface->dialog)); if (! gtk_widget_is_sensitive (action_area)) return; switch (response_id) { case RESPONSE_RESET: script_fu_reset (script); break; case GTK_RESPONSE_OK: gtk_widget_set_sensitive (sf_interface->table, FALSE); gtk_widget_set_sensitive (action_area, FALSE); script_fu_ok (script); gtk_widget_destroy (sf_interface->dialog); break; default: sf_status = GIMP_PDB_CANCEL; gtk_widget_destroy (sf_interface->dialog); break; } }
static void terminal_profile_editor_focus_widget (GtkWidget *editor, const char *widget_name) { GtkBuilder *builder; GtkWidget *widget, *page, *page_parent; if (widget_name == NULL) return; builder = g_object_get_data (G_OBJECT (editor), "builder"); widget = GTK_WIDGET (gtk_builder_get_object (builder, widget_name)); if (widget == NULL) return; page = widget; while (page != NULL && (page_parent = gtk_widget_get_parent (page)) != NULL && !GTK_IS_NOTEBOOK (page_parent)) page = page_parent; page_parent = gtk_widget_get_parent (page); if (page != NULL && GTK_IS_NOTEBOOK (page_parent)) { GtkNotebook *notebook; notebook = GTK_NOTEBOOK (page_parent); gtk_notebook_set_current_page (notebook, gtk_notebook_page_num (notebook, page)); } if (gtk_widget_is_sensitive (widget)) gtk_widget_grab_focus (widget); }
static void update_autologin (GtkWidget *widget, UmLoginOptions *d) { GtkComboBox *combo = GTK_COMBO_BOX (widget); GtkTreeModel *model; GtkTreeIter iter; UmUser *user; gboolean enabled; if (!gtk_widget_is_sensitive (widget)) return; model = gtk_combo_box_get_model (combo); gtk_combo_box_get_active_iter (combo, &iter); gtk_tree_model_get (model, &iter, AUTOLOGIN_USER_COL, &user, -1); if (user) { enabled = TRUE; } else { enabled = FALSE; user = um_user_manager_get_user_by_id (d->manager, getuid ()); g_object_ref (user); } um_user_set_automatic_login (user, enabled); g_object_unref (user); }
static gboolean window_key_press_event (GtkWidget *win, GdkEventKey *event, GsShell *shell) { GsShellPrivate *priv = gs_shell_get_instance_private (shell); GdkKeymap *keymap; GdkModifierType state; gboolean is_rtl; GtkWidget *button; button = GTK_WIDGET (gtk_builder_get_object (priv->builder, "button_back")); if (!gtk_widget_is_visible (button) || !gtk_widget_is_sensitive (button)) return GDK_EVENT_PROPAGATE; state = event->state; keymap = gdk_keymap_get_default (); gdk_keymap_add_virtual_modifiers (keymap, &state); state = state & gtk_accelerator_get_default_mod_mask (); is_rtl = gtk_widget_get_direction (button) == GTK_TEXT_DIR_RTL; if ((!is_rtl && state == GDK_MOD1_MASK && event->keyval == GDK_KEY_Left) || (is_rtl && state == GDK_MOD1_MASK && event->keyval == GDK_KEY_Right) || event->keyval == GDK_KEY_Back) { gtk_widget_activate (button); return GDK_EVENT_STOP; } return GDK_EVENT_PROPAGATE; }
static void update (void) { GString *s; char *font_desc; char *font_settings; const char *text; gboolean has_feature; int i; text = gtk_entry_get_text (GTK_ENTRY (entry)); font_desc = gtk_font_chooser_get_font (GTK_FONT_CHOOSER (font)); s = g_string_new (""); has_feature = FALSE; for (i = 0; i < 24; i++) { if (!gtk_widget_is_sensitive (toggle[i])) continue; if (GTK_IS_RADIO_BUTTON (toggle[i])) { if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (toggle[i]))) { if (has_feature) g_string_append (s, ", "); g_string_append (s, gtk_buildable_get_name (GTK_BUILDABLE (toggle[i]))); g_string_append (s, " 1"); has_feature = TRUE; } } else { if (has_feature) g_string_append (s, ", "); g_string_append (s, gtk_buildable_get_name (GTK_BUILDABLE (toggle[i]))); if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (toggle[i]))) g_string_append (s, " 1"); else g_string_append (s, " 0"); has_feature = TRUE; } } font_settings = g_string_free (s, FALSE); gtk_label_set_text (GTK_LABEL (settings), font_settings); s = g_string_new (""); g_string_append_printf (s, "<span font_desc='%s' font_features='%s'>%s</span>", font_desc, font_settings, text); gtk_label_set_markup (GTK_LABEL (label), s->str); g_string_free (s, TRUE); g_free (font_desc); g_free (font_settings); }
/*! \brief hte TTM expose event which handles redraw after being unobscured \param widget is hte pointer to the TTM drawingarea \param event is the pointers to the GdkEventExpose structure \param data is unused \returns TRUE */ G_MODULE_EXPORT gboolean logger_display_expose_event(GtkWidget * widget, GdkEventExpose *event , gpointer data) { cairo_t *cr = NULL; GtkAllocation allocation; GdkWindow *window = gtk_widget_get_window(widget); gtk_widget_get_allocation(widget,&allocation); ENTER(); #if GTK_MINOR_VERSION >= 18 if (gtk_widget_is_sensitive(GTK_WIDGET(widget))) #else if (GTK_WIDGET_IS_SENSITIVE(GTK_WIDGET(widget))) #endif { cr = gdk_cairo_create(window); gdk_cairo_set_source_pixmap(cr,ttm_data->pixmap,0,0); cairo_rectangle(cr,event->area.x,event->area.y,event->area.width, event->area.height); cairo_fill(cr); cairo_destroy(cr); } else /* INSENSITIVE display so grey it */ { cr = gdk_cairo_create(window); gdk_cairo_set_source_pixmap(cr,ttm_data->pixmap,0,0); cairo_rectangle(cr,event->area.x,event->area.y,event->area.width, event->area.height); cairo_fill(cr); cairo_set_source_rgba (cr, 0.3,0.3,0.3,0.5); cairo_rectangle(cr,0,0,allocation.width, allocation.height); cairo_fill(cr); cairo_destroy(cr); } EXIT(); return TRUE; }
static gboolean gail_expander_do_action (AtkAction *action, gint i) { GtkWidget *widget; GailExpander *expander; gboolean return_value = TRUE; widget = GTK_ACCESSIBLE (action)->widget; if (widget == NULL) /* * State is defunct */ return FALSE; if (!gtk_widget_is_sensitive (widget) || !gtk_widget_get_visible (widget)) return FALSE; expander = GAIL_EXPANDER (action); switch (i) { case 0: if (expander->action_idle_handler) return_value = FALSE; else expander->action_idle_handler = gdk_threads_add_idle (idle_do_action, expander); break; default: return_value = FALSE; break; } return return_value; }
static gboolean gtk_scale_button_accessible_do_action (AtkAction *action, gint i) { GtkWidget *widget; widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (action)); if (widget == NULL) return FALSE; if (!gtk_widget_is_sensitive (widget) || !gtk_widget_get_visible (widget)) return FALSE; switch (i) { case 0: g_signal_emit_by_name (widget, "popup"); return TRUE; case 1: g_signal_emit_by_name (widget, "popdown"); return TRUE; default: return FALSE; } }
static void selectcolor_paint(GtkWidget *widget) { cairo_t *cr; cr = gdk_cairo_create(widget->window); cairo_fill(cr); gint color = SELECT_COLOR(widget)->color; gint circle = SELECT_COLOR(widget)->circle; double r = ((color & 0xff0000) >> 16) / 255.0; double g = ((color & 0xff00) >> 8) / 255.0; double b = ((color & 0xff)) / 255.0; gboolean sensitiv = gtk_widget_is_sensitive(widget); int x = widget->allocation.x; int y = widget->allocation.y; int width = 10; if (!sensitiv) { r = r / 2 + 0.5; g = g / 2 + 0.5; b = b / 2 + 0.5; } double radius = 0; if (widget->allocation.width > widget->allocation.height) { width = widget->allocation.height; x += (widget->allocation.width - width) / 2; radius = widget->allocation.height / 2.0; } else { width = widget->allocation.width; y += (widget->allocation.height - width) / 2; radius = widget->allocation.width / 2.0; } cairo_set_source_rgb(cr, r, g, b); if (circle) { cairo_arc(cr, radius + x, radius + y, radius - 1, 0, 2 * M_PI); } else { cairo_rectangle(cr, x + 1, y + 1, width - 2, width - 2); } cairo_fill(cr); if (sensitiv) { cairo_set_source_rgb(cr, 0, 0, 0); } else { cairo_set_source_rgb(cr, 0.5, 0.5, 0.5); } if (circle) { cairo_arc(cr, radius + x, radius + y, radius - 1, 0, 2 * M_PI); } else { cairo_rectangle(cr, x + 1, y + 1, width - 2, width - 2); } cairo_stroke(cr); cairo_destroy(cr); }
static void server_or_username_combobox_entry_changed (GtkEditable *editable, gpointer user_data) { GtkButton *connect_button = user_data; gchar *server = gtk_editable_get_chars(GTK_EDITABLE(ui->connect_server_combobox_entry), 0, -1); gchar *username = gtk_editable_get_chars(GTK_EDITABLE(ui->connect_username_combobox_entry), 0, -1); if (strlen(server) > 0 && strlen(username) > 0) { if (gtk_widget_is_sensitive(GTK_WIDGET(connect_button)) == 0) gtk_widget_set_sensitive(GTK_WIDGET(connect_button), 1); } else if (gtk_widget_is_sensitive(GTK_WIDGET(connect_button)) == 1) gtk_widget_set_sensitive(GTK_WIDGET(connect_button), 0); g_free(server); g_free(username); }
/* Override the default GTK2.4 handler, which would make menu bindings not work when the menu-bar is hidden. */ static gboolean menu_canacaccel(GtkWidget *widget, guint signal_id, gpointer user_data) { /* GTK2.2 behaviour */ #if GTK_CHECK_VERSION(2,20,0) return gtk_widget_is_sensitive(widget); #else return GTK_WIDGET_IS_SENSITIVE(widget); #endif }
static void gtk_button_state_flags_changed (GtkWidget *widget, GtkStateFlags previous_state) { GtkButton *button = GTK_BUTTON (widget); if (!gtk_widget_is_sensitive (widget)) gtk_button_do_release (button, FALSE); }
static void gimp_controller_list_activate_item (GimpContainerView *view, GimpViewable *viewable, gpointer insert_data, GimpControllerList *list) { if (gtk_widget_is_sensitive (list->edit_button)) gtk_button_clicked (GTK_BUTTON (list->edit_button)); }
static gboolean menuIsSelectable(GtkWidget *menu) { return !((!gtk_bin_get_child(GTK_BIN(menu)) && G_OBJECT_TYPE(menu) == GTK_TYPE_MENU_ITEM) || GTK_IS_SEPARATOR_MENU_ITEM(menu) || !gtk_widget_is_sensitive(menu) || !gtk_widget_get_visible(menu)); }
static void gimp_controller_list_row_activated (GtkTreeView *tv, GtkTreePath *path, GtkTreeViewColumn *column, GimpControllerList *list) { if (gtk_widget_is_sensitive (list->add_button)) gtk_button_clicked (GTK_BUTTON (list->add_button)); }
/* Handle exposure events for the color picker's drawing area */ static gint expose_event (GtkWidget *widget, GdkEventExpose *event, gpointer data) { GtkColorButton *color_button = GTK_COLOR_BUTTON (data); GtkAllocation allocation; cairo_pattern_t *checkered; cairo_t *cr; cr = gdk_cairo_create (event->window); gtk_widget_get_allocation (widget, &allocation); gdk_cairo_rectangle (cr, &allocation); cairo_clip (cr); if (gtk_color_button_has_alpha (color_button)) { cairo_save (cr); cairo_set_source_rgb (cr, CHECK_DARK, CHECK_DARK, CHECK_DARK); cairo_paint (cr); cairo_set_source_rgb (cr, CHECK_LIGHT, CHECK_LIGHT, CHECK_LIGHT); cairo_scale (cr, CHECK_SIZE, CHECK_SIZE); checkered = gtk_color_button_get_checkered (); cairo_mask (cr, checkered); cairo_pattern_destroy (checkered); cairo_restore (cr); cairo_set_source_rgba (cr, color_button->priv->color.red / 65535., color_button->priv->color.green / 65535., color_button->priv->color.blue / 65535., color_button->priv->alpha / 65535.); } else { gdk_cairo_set_source_color (cr, &color_button->priv->color); } cairo_paint (cr); if (!gtk_widget_is_sensitive (GTK_WIDGET (color_button))) { gdk_cairo_set_source_color (cr, >K_WIDGET(color_button)->style->bg[GTK_STATE_INSENSITIVE]); checkered = gtk_color_button_get_checkered (); cairo_mask (cr, checkered); cairo_pattern_destroy (checkered); } cairo_destroy (cr); return FALSE; }
static void palette_import_image_add (GimpContainer *container, GimpImage *image, ImportDialog *dialog) { if (! gtk_widget_is_sensitive (dialog->image_radio)) { gtk_widget_set_sensitive (dialog->image_radio, TRUE); gimp_context_set_image (dialog->context, image); } }
static void gimp_color_button_state_changed (GtkWidget *widget, GtkStateType prev_state) { g_return_if_fail (GIMP_IS_COLOR_BUTTON (widget)); if (! gtk_widget_is_sensitive (widget) && GIMP_COLOR_BUTTON (widget)->dialog) gtk_widget_hide (GIMP_COLOR_BUTTON (widget)->dialog); if (GTK_WIDGET_CLASS (parent_class)->state_changed) GTK_WIDGET_CLASS (parent_class)->state_changed (widget, prev_state); }