static void vnr_message_area_show_basic (VnrMessageArea *msg_area, gboolean critical, const char *message, gboolean close_image) { char *warning; if(!msg_area->initialized) { vnr_message_area_initialize(msg_area); } msg_area->is_critical = critical; if(critical) gtk_image_set_from_stock (GTK_IMAGE(msg_area->image), GTK_STOCK_DIALOG_ERROR, GTK_ICON_SIZE_DIALOG); else gtk_image_set_from_stock (GTK_IMAGE(msg_area->image), GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG); msg_area->is_critical = critical; warning = g_markup_printf_escaped ("<span weight=\"bold\">%s</span>", message); gtk_label_set_markup(GTK_LABEL(msg_area->message), warning); g_free (warning); if(close_image == TRUE) vnr_window_close(msg_area->vnr_win); }
static void image_fullscreen_button ( GtkWidget *widget, AnypaperPreview *preview) { GtkWidget *button, *image_button; button = widget; if (preview->priv->state == WINDOW_NORMAL_STATE) { gtk_button_set_label (GTK_BUTTON(button), GTK_STOCK_LEAVE_FULLSCREEN); image_button = gtk_button_get_image (GTK_BUTTON(button)); gtk_image_set_from_stock (GTK_IMAGE(image_button), GTK_STOCK_LEAVE_FULLSCREEN, GTK_ICON_SIZE_BUTTON); gtk_widget_show(image_button);gtk_widget_hide(preview->priv->hbox); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(preview->priv->window2), GTK_POLICY_NEVER, GTK_POLICY_NEVER); preview->priv->state = WINDOW_FULLSCREEN_STATE; } else { gtk_button_set_label (GTK_BUTTON(button), GTK_STOCK_FULLSCREEN); image_button = gtk_button_get_image (GTK_BUTTON(button)); gtk_image_set_from_stock (GTK_IMAGE(image_button), GTK_STOCK_FULLSCREEN, GTK_ICON_SIZE_BUTTON); gtk_widget_show(image_button);gtk_widget_show(preview->priv->hbox); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(preview->priv->window2), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); preview->priv->state = WINDOW_NORMAL_STATE; } }
static void update_play_button (GthMediaViewerPage *self, GstState new_state) { if (! self->priv->playing && (new_state == GST_STATE_PLAYING)) { self->priv->playing = TRUE; gtk_image_set_from_stock (GTK_IMAGE (GET_WIDGET ("button_play_image")), GTK_STOCK_MEDIA_PAUSE, GTK_ICON_SIZE_LARGE_TOOLBAR); gtk_widget_set_tooltip_text (GET_WIDGET ("button_play_image"), _("Pause")); if (self->priv->update_progress_id == 0) self->priv->update_progress_id = gdk_threads_add_timeout (PROGRESS_DELAY, update_progress_cb, self); } else if (self->priv->playing && (new_state != GST_STATE_PLAYING)) { self->priv->playing = FALSE; gtk_image_set_from_stock (GTK_IMAGE (GET_WIDGET ("button_play_image")), GTK_STOCK_MEDIA_PLAY, GTK_ICON_SIZE_LARGE_TOOLBAR); gtk_widget_set_tooltip_text (GET_WIDGET ("button_play_image"), _("Play")); if (self->priv->update_progress_id != 0) { g_source_remove (self->priv->update_progress_id); self->priv->update_progress_id = 0; } } gth_viewer_page_update_sensitivity (GTH_VIEWER_PAGE (self)); }
// Another device selected from list void evt_changeDevices() { int status; pcm.BufferDrop = FALSE; Abort = TRUE; pthread_join(thread1, NULL); if (pcm.handle != NULL) snd_pcm_close(pcm.handle); status = initPcmDevice(gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(gui.combo_card))); switch(status) { case 0: gtk_image_set_from_stock(GTK_IMAGE(gui.image_devstatus),GTK_STOCK_YES,GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_widget_set_tooltip_text(gui.image_devstatus, "Device successfully opened"); break; case -1: gtk_image_set_from_stock(GTK_IMAGE(gui.image_devstatus),GTK_STOCK_DIALOG_WARNING,GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_widget_set_tooltip_text(gui.image_devstatus, "Device was opened, but doesn't support 44100 Hz"); break; case -2: gtk_image_set_from_stock(GTK_IMAGE(gui.image_devstatus),GTK_STOCK_DIALOG_ERROR,GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_widget_set_tooltip_text(gui.image_devstatus, "Failed to open device"); break; } g_key_file_set_string(config,"slowrx","device",gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(gui.combo_card))); pthread_create (&thread1, NULL, Listen, NULL); }
static gboolean permission_checker_thread (gpointer data) { if (permission_check_requested == TRUE) { //the answer hasn't arrived yet return TRUE; } else { //the answer has arrived g_assert(perm_result != PERMISSION_UNKNOWN); if (perm_result == PERMISSION_ALLOWED) { gtk_image_set_from_stock(GTK_IMAGE(permission_status_icon), GTK_STOCK_YES, GTK_ICON_SIZE_SMALL_TOOLBAR); gchar *markup = g_markup_printf_escaped(_("OK. Scrobbling for user: %s"), username); gtk_label_set_markup(GTK_LABEL(permission_status_label), markup); gtk_widget_set_sensitive(revoke_button, TRUE); } else if (perm_result == PERMISSION_DENIED) { gtk_image_set_from_stock(GTK_IMAGE(permission_status_icon), GTK_STOCK_NO, GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_image_set_from_stock(GTK_IMAGE(additional_details_icon), GTK_STOCK_INFO, GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_label_set_label(GTK_LABEL(permission_status_label), _("Permission Denied")); gtk_label_set_markup(GTK_LABEL(details_label_first), _("Access the following link to allow Audacious to scrobble your plays:")); gchar *url = g_markup_printf_escaped("http://www.last.fm/api/auth/?api_key=%s&token=%s", SCROBBLER_API_KEY, request_token); gtk_link_button_set_uri(GTK_LINK_BUTTON(url_button), url); gtk_button_set_label(GTK_BUTTON(url_button), url); gtk_widget_show(url_button); g_free(url); gtk_label_set_markup(GTK_LABEL(details_label_second), _("Keep this window open and click 'Check Permission' again.\n")); gtk_label_set_label(GTK_LABEL(additional_details_label), _("Don't worry. Your scrobbles are saved on your computer.\n" "They will be submitted as soon as Audacious is allowed to do so.")); } else if (perm_result == PERMISSION_NONET) { gtk_image_set_from_stock(GTK_IMAGE(permission_status_icon), GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_image_set_from_stock(GTK_IMAGE(additional_details_icon), GTK_STOCK_INFO, GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_label_set_label(GTK_LABEL(permission_status_label), _("Network Problem.")); gtk_label_set_label(GTK_LABEL(details_label_first), _("There was a problem contacting Last.fm. Please try again later.")); gtk_label_set_label(GTK_LABEL(additional_details_label), _("Don't worry. Your scrobbles are saved on your computer.\n" "They will be submitted as soon as Audacious is allowed to do so.")); } perm_result = PERMISSION_UNKNOWN; gtk_widget_set_sensitive(button, TRUE); return FALSE; } }
void on_models_ident_changed(GtkEntry *entry, Logbook *logbook) { entry_clamp_models_ident(entry); if (models_ident_validate(logbook)) { gtk_image_set_from_stock(GTK_IMAGE(logbook->models_ident_valid_wart), IMAGE_INVAL ,GTK_ICON_SIZE_BUTTON); } else { gtk_image_set_from_stock(GTK_IMAGE(logbook->models_ident_valid_wart), IMAGE_KEY ,GTK_ICON_SIZE_BUTTON); } edctrl_set_modified(logbook->models_edctrl); }
static void gimmix_status_changed (MpdObj *mo, ChangedStatusType id) { if (id&MPD_CST_SONGID) { gimmix_set_song_info (); gimmix_update_current_playlist (); } if (id&MPD_CST_STATE) { int state = mpd_player_get_state (gmo); if (state == MPD_PLAYER_PLAY) { gtk_image_set_from_stock (GTK_IMAGE(image_play), "gtk-media-pause", GTK_ICON_SIZE_BUTTON); gtk_tooltips_set_tip (play_button_tooltip, play_button, _("Pause <x or c>"), NULL); gimmix_set_song_info (); } if (state == MPD_PLAYER_PAUSE) { gtk_image_set_from_stock (GTK_IMAGE(image_play), "gtk-media-play", GTK_ICON_SIZE_BUTTON); gtk_tooltips_set_tip (play_button_tooltip, play_button, _("Play <x or c>"), NULL); } if (state == MPD_PLAYER_STOP) { gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.0); gtk_progress_bar_set_text (GTK_PROGRESS_BAR(progress), _("Stopped")); if (strncasecmp(cfg_get_key_value(conf, "enable_systray"), "true", 4) == 0) { gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(tooltip->progressbar), 0.0); gtk_progress_bar_set_text (GTK_PROGRESS_BAR(tooltip->progressbar), _("Stopped")); } gimmix_show_ver_info (); gtk_image_set_from_stock (GTK_IMAGE(image_play), "gtk-media-play", GTK_ICON_SIZE_BUTTON); gtk_tooltips_set_tip (play_button_tooltip, play_button, _("Play <x or c>"), NULL); } g_object_ref_sink (play_button_tooltip); gimmix_update_current_playlist (); } if (id&MPD_CST_PLAYLIST) gimmix_update_current_playlist (); if (id&MPD_CST_VOLUME) gimmix_update_volume (); if (id&MPD_CST_RANDOM) gimmix_update_shuffle (); if (id&MPD_CST_REPEAT) gimmix_update_repeat (); return; }
static void workspaceview_refresh( vObject *vobject ) { Workspaceview *wview = WORKSPACEVIEW( vobject ); Workspace *ws = WORKSPACE( VOBJECT( wview )->iobject ); #ifdef DEBUG printf( "workspaceview_refresh: %p %s\n", ws, IOBJECT( ws )->name ); #endif /*DEBUG*/ gtk_widget_set_sensitive( GTK_WIDGET( wview ), !ws->locked ); workspace_jump_update( ws, wview->popup_jump ); if( ws->rpane_open && !wview->rpane->open ) pane_animate_open( wview->rpane ); if( !ws->rpane_open && wview->rpane->open ) pane_animate_closed( wview->rpane ); if( ws->lpane_open && !wview->lpane->open ) pane_animate_open( wview->lpane ); if( !ws->lpane_open && wview->lpane->open ) pane_animate_closed( wview->lpane ); if( wview->label ) { gtk_label_set_text( GTK_LABEL( wview->label ), IOBJECT( ws )->name ); if( IOBJECT( ws )->caption ) set_tooltip( wview->label, "%s", IOBJECT( ws )->caption ); if( ws->locked ) gtk_image_set_from_stock( GTK_IMAGE( wview->padlock ), STOCK_LOCK, GTK_ICON_SIZE_MENU ); else gtk_image_clear( GTK_IMAGE( wview->padlock ) ); if( ws->errors ) gtk_image_set_from_stock( GTK_IMAGE( wview->alert ), STOCK_ALERT, GTK_ICON_SIZE_MENU ); else gtk_image_clear( GTK_IMAGE( wview->alert ) ); } VOBJECT_CLASS( parent_class )->refresh( vobject ); }
static void avatar_chooser_update_preview_cb (GtkFileChooser *file_chooser, EmpathyAvatarChooser *chooser) { gchar *filename; filename = gtk_file_chooser_get_preview_filename (file_chooser); if (filename) { GtkWidget *image; GdkPixbuf *pixbuf = NULL; GdkPixbuf *scaled_pixbuf; pixbuf = gdk_pixbuf_new_from_file (filename, NULL); image = gtk_file_chooser_get_preview_widget (file_chooser); if (pixbuf) { scaled_pixbuf = empathy_pixbuf_scale_down_if_necessary (pixbuf, AVATAR_SIZE_SAVE); gtk_image_set_from_pixbuf (GTK_IMAGE (image), scaled_pixbuf); g_object_unref (scaled_pixbuf); g_object_unref (pixbuf); } else { gtk_image_set_from_stock (GTK_IMAGE (image), "gtk-dialog-question", GTK_ICON_SIZE_DIALOG); } g_free (filename); } gtk_file_chooser_set_preview_widget_active (file_chooser, TRUE); }
static void update_icon (SeahorseApplet *sapplet) { SeahorseAppletPrivate *priv = SEAHORSE_APPLET_GET_PRIVATE (sapplet); const char *stock = NULL; if (seahorse_gconf_get_boolean (SHOW_CLIPBOARD_STATE_KEY)) { switch (priv->clipboard_contents) { case SEAHORSE_TEXT_TYPE_NONE: stock = ICON_CLIPBOARD_UNKNOWN; break; case SEAHORSE_TEXT_TYPE_PLAIN: stock = ICON_CLIPBOARD_TEXT; break; case SEAHORSE_TEXT_TYPE_KEY: stock = ICON_CLIPBOARD_KEY; break; case SEAHORSE_TEXT_TYPE_MESSAGE: stock = ICON_CLIPBOARD_ENCRYPTED; break; case SEAHORSE_TEXT_TYPE_SIGNED: stock = ICON_CLIPBOARD_SIGNED; break; default: g_assert_not_reached (); return; }; } else { stock = ICON_CLIPBOARD_DEFAULT; } gtk_image_set_from_stock (GTK_IMAGE (priv->image), stock, GTK_ICON_SIZE_LARGE_TOOLBAR); }
static void gimp_file_entry_check_filename (GimpFileEntry *entry) { gchar *utf8; gchar *filename; gboolean exists; if (! entry->check_valid || ! entry->file_exists) return; utf8 = gtk_editable_get_chars (GTK_EDITABLE (entry->entry), 0, -1); filename = g_filename_from_utf8 (utf8, -1, NULL, NULL, NULL); g_free (utf8); if (entry->dir_only) exists = g_file_test (filename, G_FILE_TEST_IS_DIR); else exists = g_file_test (filename, G_FILE_TEST_IS_REGULAR); g_free (filename); gtk_image_set_from_stock (GTK_IMAGE (entry->file_exists), exists ? GTK_STOCK_YES : GTK_STOCK_NO, GTK_ICON_SIZE_BUTTON); }
static void pidgin_mini_dialog_set_property(GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { PidginMiniDialog *self = PIDGIN_MINI_DIALOG(object); PidginMiniDialogPrivate *priv = PIDGIN_MINI_DIALOG_GET_PRIVATE(self); switch (property_id) { case PROP_TITLE: mini_dialog_set_title(self, g_value_get_string(value)); break; case PROP_DESCRIPTION: mini_dialog_set_description(self, g_value_get_string(value)); break; case PROP_ICON_NAME: gtk_image_set_from_stock(priv->icon, g_value_get_string(value), gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL)); break; case PROP_CUSTOM_ICON: gtk_image_set_from_pixbuf(priv->icon, g_value_get_object(value)); break; case PROP_ENABLE_DESCRIPTION_MARKUP: priv->enable_description_markup = g_value_get_boolean(value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); } }
static void image_clicked_cb (GtkWidget *widget, gpointer data) { gtk_image_set_from_stock (GTK_IMAGE (gtk_image_menu_item_get_image ( GTK_IMAGE_MENU_ITEM (widget))), GTK_STOCK_OPEN, GTK_ICON_SIZE_MENU); }
static void set_item_stock (GtkWidget *mi, const char *stock_id) { GtkWidget *image; image = gtk_image_menu_item_get_image (GTK_IMAGE_MENU_ITEM (mi)); if (stock_id == NULL) { if (image != NULL) gtk_widget_destroy (image); return; } if (image == NULL) { image = gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_MENU); gtk_widget_show (image); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mi), image); } else { gtk_image_set_from_stock (GTK_IMAGE (image), stock_id, GTK_ICON_SIZE_MENU); } }
GtkWidget * picture_create_widget (GtkWidget * dlg) { GtkWidget *sw; sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_NONE); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), options.hscroll_policy, options.vscroll_policy); viewport = gtk_viewport_new (gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (sw)), gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (sw))); gtk_container_add (GTK_CONTAINER (sw), viewport); picture = gtk_image_new (); gtk_container_add (GTK_CONTAINER (viewport), picture); /* load picture */ if (options.common_data.uri && g_file_test (options.common_data.uri, G_FILE_TEST_EXISTS)) load_picture (options.common_data.uri); else gtk_image_set_from_stock (GTK_IMAGE (picture), "gtk-missing-image", GTK_ICON_SIZE_DIALOG); if (loaded && !animated) { create_popup_menu (); g_signal_connect (G_OBJECT (viewport), "button-press-event", G_CALLBACK (button_handler), NULL); g_signal_connect (G_OBJECT (viewport), "key-press-event", G_CALLBACK (key_handler), NULL); } return sw; }
static void update_image_preview (GtkFileChooser *chooser) { GtkWidget *image; gchar *file; image = gtk_file_chooser_get_preview_widget (GTK_FILE_CHOOSER (chooser)); file = gtk_file_chooser_get_preview_uri (chooser); if (file != NULL) { GdkPixbuf *pixbuf = NULL; pixbuf = create_preview_pixbuf (file); g_free (file); if (pixbuf != NULL) { gtk_image_set_from_pixbuf (GTK_IMAGE (image), pixbuf); g_object_unref (pixbuf); } else { gtk_image_set_from_stock (GTK_IMAGE (image), "gtk-dialog-question", GTK_ICON_SIZE_DIALOG); } } gtk_file_chooser_set_preview_widget_active (chooser, file != NULL); }
void linphone_gtk_in_call_view_set_in_call(LinphoneCall *call){ GtkWidget *callview=(GtkWidget*)linphone_call_get_user_pointer(call); GtkWidget *status=linphone_gtk_get_widget(callview,"in_call_status"); GtkWidget *callee=linphone_gtk_get_widget(callview,"in_call_uri"); GtkWidget *duration=linphone_gtk_get_widget(callview,"in_call_duration"); GtkWidget *animation=linphone_gtk_get_widget(callview,"in_call_animation"); GdkPixbufAnimation *pbuf=create_pixbuf_animation("incall_anim.gif"); guint taskid=GPOINTER_TO_INT(g_object_get_data(G_OBJECT(callview),"taskid")); display_peer_name_in_label(callee,linphone_call_get_remote_address (call)); gtk_widget_show(linphone_gtk_get_widget(callview,"mute_pause_buttons")); gtk_widget_hide(linphone_gtk_get_widget(callview,"answer_decline_panel")); gtk_label_set_markup(GTK_LABEL(status),_("<b>In call</b>")); gtk_label_set_text(GTK_LABEL(duration),_("00::00::00")); if (pbuf!=NULL){ gtk_image_set_from_animation(GTK_IMAGE(animation),pbuf); g_object_unref(G_OBJECT(pbuf)); }else gtk_image_set_from_stock(GTK_IMAGE(animation),GTK_STOCK_EXECUTE,GTK_ICON_SIZE_DIALOG); linphone_gtk_enable_mute_button( GTK_BUTTON(linphone_gtk_get_widget(callview,"incall_mute")),TRUE); if (taskid==0){ taskid=g_timeout_add(250,(GSourceFunc)linphone_gtk_in_call_view_refresh,call); g_object_set_data(G_OBJECT(callview),"taskid",GINT_TO_POINTER(taskid)); } }
void linphone_gtk_in_call_view_show_encryption(LinphoneCall *call){ GtkWidget *callview=(GtkWidget*)linphone_call_get_user_pointer(call); GtkWidget *encryption_box=linphone_gtk_get_widget(callview,"encryption_box"); GtkWidget *label=linphone_gtk_get_widget(callview,"encryption_label"); GtkWidget *status_icon=linphone_gtk_get_widget(callview,"encryption_status_icon"); GtkWidget *verify_button=linphone_gtk_get_widget(callview,"encryption_verify_button"); LinphoneMediaEncryption me=linphone_call_params_get_media_encryption(linphone_call_get_current_params(call)); bool_t verified=linphone_call_get_authentication_token_verified(call); switch(me){ case LinphoneMediaEncryptionSRTP: gtk_widget_show_all(encryption_box); gtk_label_set_markup(GTK_LABEL(label),_("Secured by SRTP")); gtk_widget_hide(status_icon); gtk_widget_hide(verify_button); break; case LinphoneMediaEncryptionZRTP: { gchar *text=g_strdup_printf(_("Secured by ZRTP - [auth token: %s]"),linphone_call_get_authentication_token(call)); gtk_label_set_markup(GTK_LABEL(label),text); g_free(text); gtk_image_set_from_stock(GTK_IMAGE(status_icon), verified ? GTK_STOCK_APPLY : GTK_STOCK_DIALOG_WARNING,GTK_ICON_SIZE_MENU); gtk_button_set_label(GTK_BUTTON(verify_button), verified ? _("Set unverified") : _("Set verified")); gtk_widget_show_all(encryption_box); } break; default: gtk_widget_hide_all(encryption_box); } }
static void set_new_pixbuf(VnrPropertiesDialog *dialog, GdkPixbuf* original) { if(dialog->thumbnail != NULL) { g_object_unref(dialog->thumbnail); dialog->thumbnail = NULL; } if(original == NULL) { gtk_image_set_from_stock(GTK_IMAGE(dialog->image), GTK_STOCK_MISSING_IMAGE, GTK_ICON_SIZE_DIALOG); return; } int width, height; width = gdk_pixbuf_get_width (original); height = gdk_pixbuf_get_height (original); vnr_tools_fit_to_size(&height, &width, 100,100); dialog->thumbnail = gdk_pixbuf_scale_simple (original, width, height, GDK_INTERP_NEAREST); }
void linphone_gtk_in_call_view_set_incoming(LinphoneCall *call, bool_t with_pause){ GtkWidget *callview=(GtkWidget*)linphone_call_get_user_pointer(call); GtkWidget *status=linphone_gtk_get_widget(callview,"in_call_status"); GtkWidget *callee=linphone_gtk_get_widget(callview,"in_call_uri"); GtkWidget *animation=linphone_gtk_get_widget(callview,"in_call_animation"); GdkPixbufAnimation *pbuf=create_pixbuf_animation("calling_anim.gif"); GtkWidget *answer_button; GtkWidget *image; gtk_label_set_markup(GTK_LABEL(status),_("<b>Incoming call</b>")); gtk_widget_show_all(linphone_gtk_get_widget(callview,"answer_decline_panel")); gtk_widget_hide(linphone_gtk_get_widget(callview,"mute_pause_buttons")); display_peer_name_in_label(callee,linphone_call_get_remote_address (call)); answer_button=linphone_gtk_get_widget(callview,"accept_call"); image=create_pixmap (linphone_gtk_get_ui_config("start_call_icon","startcall-green.png")); if (with_pause){ gtk_button_set_label(GTK_BUTTON(answer_button), _("Pause all calls\nand answer")); }else gtk_button_set_label(GTK_BUTTON(answer_button),_("Answer")); gtk_button_set_image(GTK_BUTTON(answer_button),image); gtk_widget_show(image); image=create_pixmap (linphone_gtk_get_ui_config("stop_call_icon","stopcall-red.png")); gtk_button_set_image(GTK_BUTTON(linphone_gtk_get_widget(callview,"decline_call")),image); gtk_widget_show(image); if (pbuf!=NULL){ gtk_image_set_from_animation(GTK_IMAGE(animation),pbuf); g_object_unref(G_OBJECT(pbuf)); }else gtk_image_set_from_stock(GTK_IMAGE(animation),GTK_STOCK_EXECUTE,GTK_ICON_SIZE_DIALOG); }
static void selection_changed (GtkTreeSelection *selection) { GtkTreeView *treeview; StockItemDisplay *display; GtkTreeModel *model; GtkTreeIter iter; treeview = gtk_tree_selection_get_tree_view (selection); display = g_object_get_data (G_OBJECT (treeview), "stock-display"); if (gtk_tree_selection_get_selected (selection, &model, &iter)) { StockItemInfo *info; gchar *str; gtk_tree_model_get (model, &iter, 0, &info, -1); if (info->small_icon && info->item.label) gtk_label_set_text (GTK_LABEL (display->type_label), "Icon and Item"); else if (info->small_icon) gtk_label_set_text (GTK_LABEL (display->type_label), "Icon Only"); else if (info->item.label) gtk_label_set_text (GTK_LABEL (display->type_label), "Item Only"); else gtk_label_set_text (GTK_LABEL (display->type_label), "???????"); gtk_label_set_text (GTK_LABEL (display->macro_label), info->macro); gtk_label_set_text (GTK_LABEL (display->id_label), info->id); if (info->item.label) { str = g_strdup_printf ("%s %s", info->item.label, info->accel_str); gtk_label_set_text_with_mnemonic (GTK_LABEL (display->label_accel_label), str); g_free (str); } else { gtk_label_set_text (GTK_LABEL (display->label_accel_label), ""); } if (info->small_icon) gtk_image_set_from_stock (GTK_IMAGE (display->icon_image), info->id, get_largest_size (info->id)); else gtk_image_set_from_pixbuf (GTK_IMAGE (display->icon_image), NULL); stock_item_info_free (info); } else { gtk_label_set_text (GTK_LABEL (display->type_label), "No selected item"); gtk_label_set_text (GTK_LABEL (display->macro_label), ""); gtk_label_set_text (GTK_LABEL (display->id_label), ""); gtk_label_set_text (GTK_LABEL (display->label_accel_label), ""); gtk_image_set_from_pixbuf (GTK_IMAGE (display->icon_image), NULL); } }
// Works only for buttons created with CreateButton() void SetButtonStock(GtkWidget *button, const gchar *image) { GtkWidget *alignment = gtk_bin_get_child(GTK_BIN(button)); GtkWidget *hbox = gtk_bin_get_child(GTK_BIN(alignment)); CPointerWrapper<GList> list(gtk_container_get_children(GTK_CONTAINER(hbox)), g_list_free); GtkWidget *img = GTK_WIDGET(list->data); gtk_image_set_from_stock(GTK_IMAGE(img), image, GTK_ICON_SIZE_BUTTON); }
void linphone_gtk_in_call_view_set_paused(LinphoneCall *call){ GtkWidget *callview=(GtkWidget*)linphone_call_get_user_pointer(call); GtkWidget *status=linphone_gtk_get_widget(callview,"in_call_status"); GtkWidget *animation=linphone_gtk_get_widget(callview,"in_call_animation"); gtk_widget_hide(linphone_gtk_get_widget(callview,"answer_decline_panel")); gtk_label_set_markup(GTK_LABEL(status),_("<b>Paused call</b>")); gtk_image_set_from_stock(GTK_IMAGE(animation),GTK_STOCK_MEDIA_PAUSE,GTK_ICON_SIZE_DIALOG); }
static void nsp_window_cmd_webview_expand (GtkToggleButton *button, NspWindow *win) { if ( gtk_toggle_button_get_active(button) ) { gtk_image_set_from_stock(GTK_IMAGE(gtk_builder_get_object(win->builder, "feed_item_fullscreen_image")), GTK_STOCK_LEAVE_FULLSCREEN, GTK_ICON_SIZE_BUTTON); gtk_widget_hide(GTK_WIDGET(gtk_builder_get_object(win->builder, "vbox_left_panel"))); gtk_widget_hide(GTK_WIDGET(gtk_builder_get_object(win->builder, "hbox_right_panel_header"))); gtk_widget_hide(GTK_WIDGET(gtk_builder_get_object(win->builder, "feed_item_list_win"))); } else { gtk_image_set_from_stock(GTK_IMAGE(gtk_builder_get_object(win->builder, "feed_item_fullscreen_image")), GTK_STOCK_FULLSCREEN, GTK_ICON_SIZE_BUTTON); gtk_widget_show(GTK_WIDGET(gtk_builder_get_object(win->builder, "vbox_left_panel"))); gtk_widget_show(GTK_WIDGET(gtk_builder_get_object(win->builder, "hbox_right_panel_header"))); gtk_widget_show(GTK_WIDGET(gtk_builder_get_object(win->builder, "feed_item_list_win"))); } }
/** * gdaui_set_icon_from_stock * @bar: a #GdauiBar widget. * @stock_id: a stock icon name. * @size: a tock icon size. * * Set the icon using a stock icon for the given gray bar. */ void gdaui_bar_set_icon_from_stock (GdauiBar *bar, const gchar *stock_id, GtkIconSize size) { g_return_if_fail (GDAUI_IS_BAR (bar)); gtk_image_set_from_stock (GTK_IMAGE (bar->priv->icon), stock_id, size); gdaui_bar_set_show_icon (bar, TRUE); }
// Setzt auf dem Play Button auf Play oder Pause void interface_set_playimage(const gchar *stock_id) { GtkImage *playimage = NULL; playimage = GTK_IMAGE( interface_get_widget ("image_play")); if (playimage != NULL) { gtk_image_set_from_stock(playimage, stock_id, GTK_ICON_SIZE_BUTTON); } }
static GnomeKeyringOperationGetIntCallback stored_password (GnomeKeyringResult res, guint32 val, widgets *data) { /* user_data will be the same as was passed to gnome_keyring_store_password() */ if (res != GNOME_KEYRING_RESULT_OK) { gtk_image_set_from_stock(GTK_IMAGE(data->image_credentials), "gtk-stop", GTK_ICON_SIZE_BUTTON); gtk_label_set_label(GTK_LABEL(data->label_credentials), gnome_keyring_result_to_message (res)); } }
void gedit_progress_message_area_set_stock_image (GeditProgressMessageArea *area, const gchar *stock_id) { g_return_if_fail (GEDIT_IS_PROGRESS_MESSAGE_AREA (area)); g_return_if_fail (stock_id != NULL); gtk_image_set_from_stock (GTK_IMAGE (area->priv->image), stock_id, GTK_ICON_SIZE_SMALL_TOOLBAR); }
static void update_preview (GtkFileChooser *chooser, GnomeDesktopThumbnailFactory *thumb_factory) { gchar *uri; uri = gtk_file_chooser_get_preview_uri (chooser); if (uri) { GdkPixbuf *pixbuf = NULL; const gchar *mime_type = NULL; GFile *file; GFileInfo *file_info; GtkWidget *preview; preview = gtk_file_chooser_get_preview_widget (chooser); file = g_file_new_for_uri (uri); file_info = g_file_query_info (file, G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE, G_FILE_QUERY_INFO_NONE, NULL, NULL); g_object_unref (file); if (file_info != NULL) { mime_type = g_file_info_get_content_type (file_info); g_object_unref (file_info); } if (mime_type) { pixbuf = gnome_desktop_thumbnail_factory_generate_thumbnail (thumb_factory, uri, mime_type); } gtk_dialog_set_response_sensitive (GTK_DIALOG (chooser), GTK_RESPONSE_ACCEPT, (pixbuf != NULL)); if (pixbuf != NULL) { gtk_image_set_from_pixbuf (GTK_IMAGE (preview), pixbuf); g_object_unref (pixbuf); } else { gtk_image_set_from_stock (GTK_IMAGE (preview), GTK_STOCK_DIALOG_QUESTION, GTK_ICON_SIZE_DIALOG); } g_free (uri); } gtk_file_chooser_set_preview_widget_active (chooser, TRUE); }
static gboolean test_maybe_timeout (struct test_data_t *data) { double_click_state = DOUBLE_CLICK_TEST_OFF; gtk_image_set_from_stock (GTK_IMAGE (data->image), MOUSE_DBLCLCK_OFF, mouse_capplet_dblclck_icon_get_size()); *data->timeout_id = 0; return FALSE; }