QString Application::icon() const { if (!m_overrideIconPath.isEmpty()) { return m_overrideIconPath; } if (sticky() && (m_appInfo != NULL)) { GCharPointer ptr(g_icon_to_string(g_app_info_get_icon(m_appInfo.data()))); return QString::fromUtf8(ptr.data()); } if (m_application != NULL) { return m_application->icon(); } if (m_appInfo != NULL) { GCharPointer ptr(g_icon_to_string(g_app_info_get_icon(m_appInfo.data()))); return QString::fromUtf8(ptr.data()); } if (m_snStartupSequence != NULL) { return QString::fromUtf8(sn_startup_sequence_get_icon_name(m_snStartupSequence.data())); } return QString(); }
static void _update_icon_from_icon_theme (PengeAppTile *tile) { PengeAppTilePrivate *priv = GET_PRIVATE (tile); gchar *icon_path; GError *error = NULL; GIcon *icon; icon = g_app_info_get_icon (priv->app_info); if (G_IS_FILE_ICON (icon)) { icon_path = g_icon_to_string (icon); } if (!clutter_texture_set_from_file (CLUTTER_TEXTURE (priv->tex), icon_path, &error)) { g_warning (G_STRLOC ": Error loading texture from file: %s", error->message); g_clear_error (&error); } g_free (icon_path); }
/** * cinnamon_app_create_icon_texture: * * Look up the icon for this application, and create a #ClutterTexture * for it at the given size. * * Return value: (transfer none): A floating #ClutterActor */ ClutterActor * cinnamon_app_create_icon_texture (CinnamonApp *app, int size) { GIcon *icon; ClutterActor *ret; ret = NULL; if (app->entry == NULL) return window_backed_app_get_icon (app, size); icon = g_app_info_get_icon (G_APP_INFO (gmenu_tree_entry_get_app_info (app->entry))); if (icon != NULL) ret = st_texture_cache_load_gicon (st_texture_cache_get_default (), NULL, icon, size); if (ret == NULL) { icon = g_themed_icon_new ("application-x-executable"); ret = st_texture_cache_load_gicon (st_texture_cache_get_default (), NULL, icon, size); g_object_unref (icon); } return ret; }
static MxAction * _action_new_from_desktop_file (const gchar *desktop_file_id) { GDesktopAppInfo *dai; dai = g_desktop_app_info_new (desktop_file_id); if (dai) { MxAction *action; GAppInfo *ai; GIcon *icon; ai = G_APP_INFO (dai); action = mx_action_new_full (g_app_info_get_name (ai), g_app_info_get_display_name (ai), G_CALLBACK (_app_launcher_cb), (gpointer)g_app_info_get_commandline (ai)); icon = g_app_info_get_icon (ai); if (icon) { gchar *icon_name; icon_name = g_icon_to_string (icon); mx_action_set_icon (action, icon_name); g_free (icon_name); } return action; } return NULL; }
void cc_shell_model_add_item (CcShellModel *model, CcPanelCategory category, GAppInfo *appinfo, const char *id) { GIcon *icon = g_app_info_get_icon (appinfo); const gchar *name = g_app_info_get_name (appinfo); const gchar *comment = g_app_info_get_description (appinfo); char **keywords; char *casefolded_name, *casefolded_description; casefolded_name = cc_util_normalize_casefold_and_unaccent (name); casefolded_description = cc_util_normalize_casefold_and_unaccent (comment); keywords = get_casefolded_keywords (appinfo); gtk_list_store_insert_with_values (GTK_LIST_STORE (model), NULL, 0, COL_NAME, name, COL_CASEFOLDED_NAME, casefolded_name, COL_APP, appinfo, COL_ID, id, COL_CATEGORY, category, COL_DESCRIPTION, comment, COL_CASEFOLDED_DESCRIPTION, casefolded_description, COL_GICON, icon, COL_KEYWORDS, keywords, -1); g_free (casefolded_name); g_free (casefolded_description); g_strfreev (keywords); }
static void on_content_type_finished(GObject* src_obj, GAsyncResult* res, gpointer user_data) { AutoRun* data = (AutoRun*)user_data; GMount* mount = G_MOUNT(src_obj); char** types; char* desc = NULL; types = g_mount_guess_content_type_finish(mount, res, NULL); if(types) { GtkTreeIter it; GList* apps = NULL, *l; char** type; if(types[0]) { for(type=types;*type;++type) { l = g_app_info_get_all_for_type(*type); if(l) apps = g_list_concat(apps, l); } desc = g_content_type_get_description(types[0]); } g_strfreev(types); if(apps) { int pos = 0; GtkTreePath* tp; for(l = apps; l; l=l->next, ++pos) { GAppInfo* app = G_APP_INFO(l->data); gtk_list_store_insert_with_values(data->store, &it, pos, 0, g_app_info_get_icon(app), 1, g_app_info_get_name(app), 2, app, -1); g_object_unref(app); } g_list_free(apps); gtk_tree_model_get_iter_first(GTK_TREE_MODEL(data->store), &it); gtk_tree_selection_select_iter(gtk_tree_view_get_selection(data->view), &it); tp = gtk_tree_path_new_first(); gtk_tree_view_set_cursor(data->view, tp, NULL, FALSE); gtk_tree_path_free(tp); } } if(desc) { gtk_label_set_text(data->type, desc); g_free(desc); } else gtk_label_set_text(data->type, _("Removable Disk")); }
GIcon * desktop_entry_get_icon (DesktopEntry *entry) { if (entry->type == DESKTOP_ENTRY_DESKTOP) { g_return_val_if_fail (G_IS_DESKTOP_APP_INFO (((DesktopEntryDesktop*)entry)->appinfo), NULL); return g_app_info_get_icon (G_APP_INFO (((DesktopEntryDesktop*)entry)->appinfo)); } return ((DesktopEntryDirectory*)entry)->icon; }
static void gtk_app_chooser_button_populate (GtkAppChooserButton *self) { GList *recommended_apps = NULL, *l; GAppInfo *app; GtkTreeIter iter, iter2; GIcon *icon; gboolean cycled_recommended; #ifndef G_OS_WIN32 if (self->priv->content_type) recommended_apps = g_app_info_get_recommended_for_type (self->priv->content_type); #endif cycled_recommended = FALSE; for (l = recommended_apps; l != NULL; l = l->next) { app = l->data; icon = g_app_info_get_icon (app); if (icon == NULL) icon = g_themed_icon_new ("application-x-executable"); else g_object_ref (icon); if (cycled_recommended) { gtk_list_store_insert_after (self->priv->store, &iter2, &iter); iter = iter2; } else { get_first_iter (self->priv->store, &iter); cycled_recommended = TRUE; } gtk_list_store_set (self->priv->store, &iter, COLUMN_APP_INFO, app, COLUMN_LABEL, g_app_info_get_name (app), COLUMN_ICON, icon, COLUMN_CUSTOM, FALSE, -1); g_object_unref (icon); } if (!cycled_recommended) gtk_app_chooser_button_ensure_dialog_item (self, NULL); else gtk_app_chooser_button_ensure_dialog_item (self, &iter); gtk_combo_box_set_active (GTK_COMBO_BOX (self), 0); }
/* Now we implement a set of iterator functions that will handle item lookup hell for us. */ void menu_iterate_begin(pqi inst, menu_iter *it, int showfirst) { it->reverse = FALSE; it->showfirst = showfirst; it->si = (inst->items->next? showfirst? inst->items : inst->items->next : inst->items); it->valid = (it->si != NULL); if (it->valid) it->text = g_app_info_get_display_name(G_APP_INFO(it->si->dfile)), it->icon = g_app_info_get_icon(G_APP_INFO(it->si->dfile)); }
void menu_iterate_rbegin(pqi inst, menu_iter *it, int showfirst) { it->reverse = TRUE; it->showfirst = showfirst; it->si = inst->lastitem; it->valid = (it->si != NULL); /* Wehther or not we show the first item, whether or not this is the first item, if it exists, we return it. */ if (it->valid) it->text = g_app_info_get_display_name(G_APP_INFO(it->si->dfile)), it->icon = g_app_info_get_icon(G_APP_INFO(it->si->dfile)); }
void menu_iter_next(menu_iter* it) { if (it->reverse) it->si = it->si->prev, it->valid = (it->si != NULL && (it->showfirst || it->si->prev)); else it->si = it->si->next, it->valid = (it->si != NULL); if (it->valid) it->text = g_app_info_get_display_name(G_APP_INFO(it->si->dfile)), it->icon = g_app_info_get_icon(G_APP_INFO(it->si->dfile)); }
static void gtk_app_chooser_add_default (GtkAppChooserWidget *self, GAppInfo *app) { GtkTreeIter iter; GIcon *icon; gchar *string; gboolean unref_icon; unref_icon = FALSE; string = g_strdup_printf ("<b>%s</b>", _("Default Application")); gtk_list_store_append (self->priv->program_list_store, &iter); gtk_list_store_set (self->priv->program_list_store, &iter, COLUMN_HEADING_TEXT, string, COLUMN_HEADING, TRUE, COLUMN_DEFAULT, TRUE, -1); g_free (string); string = g_markup_printf_escaped ("%s", g_app_info_get_name (app) != NULL ? g_app_info_get_name (app) : ""); icon = g_app_info_get_icon (app); if (icon == NULL) { icon = g_themed_icon_new ("application-x-executable"); unref_icon = TRUE; } gtk_list_store_append (self->priv->program_list_store, &iter); gtk_list_store_set (self->priv->program_list_store, &iter, COLUMN_APP_INFO, app, COLUMN_GICON, icon, COLUMN_NAME, g_app_info_get_name (app), COLUMN_DESC, string, COLUMN_EXEC, g_app_info_get_executable (app), COLUMN_HEADING, FALSE, COLUMN_DEFAULT, TRUE, -1); g_free (string); if (unref_icon) g_object_unref (icon); }
static void combo_changed_cb (GtkAppChooserButton *button, gpointer user_data) { GAppInfo *app_info; app_info = gtk_app_chooser_get_app_info (GTK_APP_CHOOSER (button)); if (app_info == NULL) return; gtk_image_set_from_gicon (GTK_IMAGE (sel_image), g_app_info_get_icon (app_info)); gtk_label_set_text (GTK_LABEL (sel_name), g_app_info_get_display_name (app_info)); g_object_unref (app_info); }
static void combo_changed_cb (GtkComboBox *cb, gpointer user_data) { GAppInfo *app_info; app_info = gtk_app_chooser_get_app_info (GTK_APP_CHOOSER (cb)); if (app_info == NULL) return; gtk_image_set_from_gicon (GTK_IMAGE (sel_image), g_app_info_get_icon (app_info), GTK_ICON_SIZE_DIALOG); gtk_label_set_text (GTK_LABEL (sel_name), g_app_info_get_display_name (app_info)); g_object_unref (app_info); }
static void add_application (CcNotificationsPanel *panel, Application *app) { GtkWidget *box, *w; GIcon *icon; icon = g_app_info_get_icon (app->app_info); if (icon == NULL) icon = g_themed_icon_new ("application-x-executable"); else g_object_ref (icon); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); g_object_set_qdata_full (G_OBJECT (box), application_quark (), app, (GDestroyNotify) application_free); gtk_container_add (GTK_CONTAINER (panel->list_box), box); w = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_DIALOG); gtk_widget_set_margin_left (w, 12); gtk_container_add (GTK_CONTAINER (box), w); g_object_unref (icon); w = gtk_label_new (g_app_info_get_name (app->app_info)); gtk_container_add (GTK_CONTAINER (box), w); w = gtk_label_new (""); g_settings_bind_with_mapping (app->settings, "enable", w, "label", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_NO_SENSITIVITY, on_off_label_mapping_get, NULL, NULL, NULL); gtk_widget_set_margin_right (w, 12); gtk_widget_set_valign (w, GTK_ALIGN_CENTER); gtk_box_pack_end (GTK_BOX (box), w, FALSE, FALSE, 0); gtk_widget_show_all (box); g_hash_table_add (panel->known_applications, g_strdup (app->canonical_app_id)); }
static GList * xde_action(MenuContext *ctx, GMenuTreeEntry *ent, GDesktopAppInfo *info, const char *action) { GList *text = NULL; const char *name, *path; char *esc1, *esc2, *cmd, *p; char *s, *icon = NULL; GIcon *gicon = NULL; char *appid; name = g_desktop_app_info_get_action_name(info, action); esc1 = xde_character_escape(name, ')'); if ((appid = strdup(gmenu_tree_entry_get_desktop_file_id(ent))) && (p = strstr(appid, ".desktop"))) *p = '\0'; if (ctx->stack) gicon = gmenu_tree_directory_get_icon(ctx->stack->data); if ((path = gmenu_tree_entry_get_desktop_file_path(ent))) { GKeyFile *file = g_key_file_new(); g_key_file_load_from_file(file, path, G_KEY_FILE_NONE, NULL); icon = xde_get_action_icon(ctx, file, action, gicon, "exec", "unknown", GET_ENTRY_ICON_FLAG_XPM | GET_ENTRY_ICON_FLAG_PNG | GET_ENTRY_ICON_FLAG_JPG | GET_ENTRY_ICON_FLAG_SVG); g_key_file_unref(file); } else icon = xde_get_icon2(ctx, "exec", "unknown"); gicon = g_app_info_get_icon(G_APP_INFO(info)); if (options.launch) cmd = g_strdup_printf("xdg-launch --pointer --action='%s' %s", action, appid); else cmd = xde_get_action(info, appid, icon, action); esc2 = xde_character_escape(cmd, '}'); icon = ctx->wmm.wrap(ctx, icon); s = g_strdup_printf("%s[exec] (%s) {%s}%s\n", ctx->indent, esc1, esc2, icon); text = g_list_append(text, s); free(icon); free(appid); free(esc1); free(esc2); free(cmd); return (text); }
static void activate_open_with_application_item (GtkMenuItem *menuitem, gpointer data) { GthBrowser *browser = data; GList *items; GList *file_list; GList *uris; GList *scan; GAppInfo *appinfo; GdkAppLaunchContext *context; GError *error = NULL; items = gth_file_selection_get_selected (GTH_FILE_SELECTION (gth_browser_get_file_list_view (browser))); file_list = gth_file_list_get_files (GTH_FILE_LIST (gth_browser_get_file_list (browser)), items); uris = NULL; for (scan = file_list; scan; scan = scan->next) { GthFileData *file_data = scan->data; uris = g_list_prepend (uris, g_file_get_uri (file_data->file)); } uris = g_list_reverse (uris); appinfo = g_object_get_data (G_OBJECT (menuitem), "appinfo"); g_return_if_fail (G_IS_APP_INFO (appinfo)); context = gdk_display_get_app_launch_context (gtk_widget_get_display (GTK_WIDGET (browser))); gdk_app_launch_context_set_timestamp (context, 0); gdk_app_launch_context_set_icon (context, g_app_info_get_icon (appinfo)); if (! g_app_info_launch_uris (appinfo, uris, G_APP_LAUNCH_CONTEXT (context), &error)) { _gtk_error_dialog_from_gerror_show (GTK_WINDOW (browser), _("Could not perform the operation"), error); g_clear_error (&error); } g_object_unref (context); g_list_free (uris); _g_object_list_unref (file_list); _gtk_tree_path_list_free (items); }
static void insert_one_application (GtkAppChooserButton *self, GAppInfo *app, GtkTreeIter *iter) { GIcon *icon; icon = g_app_info_get_icon (app); if (icon == NULL) icon = g_themed_icon_new ("application-x-executable"); else g_object_ref (icon); gtk_list_store_set (self->priv->store, iter, COLUMN_APP_INFO, app, COLUMN_LABEL, g_app_info_get_name (app), COLUMN_ICON, icon, COLUMN_CUSTOM, FALSE, -1); g_object_unref (icon); }
void ephy_web_application_setup_from_desktop_file (GDesktopAppInfo *desktop_info) { GAppInfo *app_info; const char *wm_class; GIcon *icon; g_assert (G_IS_DESKTOP_APP_INFO (desktop_info)); app_info = G_APP_INFO (desktop_info); g_set_prgname (g_app_info_get_name (app_info)); g_set_application_name (g_app_info_get_display_name (app_info)); icon = g_app_info_get_icon (app_info); if (G_IS_FILE_ICON (icon)) { GFile *file = g_file_icon_get_file (G_FILE_ICON (icon)); char *path = file ? g_file_get_path (file) : NULL; if (path) { gtk_window_set_default_icon_from_file (path, NULL); g_free (path); } g_clear_object (&file); } else if (G_IS_THEMED_ICON (icon)) { const char * const *names = g_themed_icon_get_names (G_THEMED_ICON (icon)); if (names) gtk_window_set_default_icon_name (names[0]); } g_clear_object (&icon); /* We need to re-set this because we have already parsed the * options, which inits GTK+ and sets this as a side effect. */ wm_class = g_desktop_app_info_get_startup_wm_class (desktop_info); if (wm_class) gdk_set_program_class (wm_class); }
static void _launch_app (OlPlayerChooser *window, GAppInfo *app_info) { GError *err = NULL; if (!g_app_info_launch (app_info, NULL, NULL, &err)) { ol_errorf ("Cannot launch %s: %s", g_app_info_get_commandline (app_info), err->message); gchar *title = g_strdup_printf (_("Failed to launch %s"), g_app_info_get_name (app_info)); ol_player_chooser_set_info (window, title, err->message); ol_player_chooser_set_image_by_name (window, GTK_STOCK_DIALOG_ERROR); g_free (title); g_error_free (err); } else { _set_launch_app (window, app_info); gchar *title = g_strdup_printf (_("Launching %s"), g_app_info_get_name (app_info)); gchar *desc = g_strdup_printf (_("OSD Lyrics is trying to launch and connect to %s. Please wait for a second."), g_app_info_get_name (app_info)); ol_player_chooser_set_info (window, title, desc); g_free (title); g_free (desc); ol_player_chooser_set_image_by_gicon (window, g_app_info_get_icon (app_info)); _set_sensitive (window, FALSE); if (OL_IS_PLAYER_CHOOSER (window)) { _remember_cmd_if_needed (window, g_app_info_get_commandline (app_info)); gtk_dialog_response (GTK_DIALOG (window), OL_PLAYER_CHOOSER_RESPONSE_LAUNCH); } } }
void caja_autorun_prepare_combo_box (GtkWidget *combo_box, const char *x_content_type, gboolean include_ask, gboolean include_open_with_other_app, gboolean update_settings, CajaAutorunComboBoxChanged changed_cb, gpointer user_data) { GList *l; GList *app_info_list; GAppInfo *default_app_info; GtkListStore *list_store; GtkTreeIter iter; GdkPixbuf *pixbuf; int icon_size; int set_active; int n; int num_apps; gboolean pref_ask; gboolean pref_start_app; gboolean pref_ignore; gboolean pref_open_folder; CajaAutorunComboBoxData *data; GtkCellRenderer *renderer; gboolean new_data; caja_autorun_get_preferences (x_content_type, &pref_start_app, &pref_ignore, &pref_open_folder); pref_ask = !pref_start_app && !pref_ignore && !pref_open_folder; icon_size = caja_get_icon_size_for_stock_size (GTK_ICON_SIZE_MENU); set_active = -1; data = NULL; new_data = TRUE; app_info_list = g_app_info_get_all_for_type (x_content_type); default_app_info = g_app_info_get_default_for_type (x_content_type, FALSE); num_apps = g_list_length (app_info_list); list_store = gtk_list_store_new (5, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_APP_INFO, G_TYPE_STRING, G_TYPE_INT); /* no apps installed */ if (num_apps == 0) { gtk_list_store_append (list_store, &iter); pixbuf = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), GTK_STOCK_DIALOG_ERROR, icon_size, 0, NULL); /* TODO: integrate with PackageKit-mate to find applications */ gtk_list_store_set (list_store, &iter, COLUMN_AUTORUN_PIXBUF, pixbuf, COLUMN_AUTORUN_NAME, _("No applications found"), COLUMN_AUTORUN_APP_INFO, NULL, COLUMN_AUTORUN_X_CONTENT_TYPE, x_content_type, COLUMN_AUTORUN_ITEM_TYPE, AUTORUN_ASK, -1); g_object_unref (pixbuf); } else { if (include_ask) { gtk_list_store_append (list_store, &iter); pixbuf = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), GTK_STOCK_DIALOG_QUESTION, icon_size, 0, NULL); gtk_list_store_set (list_store, &iter, COLUMN_AUTORUN_PIXBUF, pixbuf, COLUMN_AUTORUN_NAME, _("Ask what to do"), COLUMN_AUTORUN_APP_INFO, NULL, COLUMN_AUTORUN_X_CONTENT_TYPE, x_content_type, COLUMN_AUTORUN_ITEM_TYPE, AUTORUN_ASK, -1); g_object_unref (pixbuf); } gtk_list_store_append (list_store, &iter); pixbuf = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), GTK_STOCK_CLOSE, icon_size, 0, NULL); gtk_list_store_set (list_store, &iter, COLUMN_AUTORUN_PIXBUF, pixbuf, COLUMN_AUTORUN_NAME, _("Do Nothing"), COLUMN_AUTORUN_APP_INFO, NULL, COLUMN_AUTORUN_X_CONTENT_TYPE, x_content_type, COLUMN_AUTORUN_ITEM_TYPE, AUTORUN_IGNORE, -1); g_object_unref (pixbuf); gtk_list_store_append (list_store, &iter); pixbuf = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), "folder-open", icon_size, 0, NULL); gtk_list_store_set (list_store, &iter, COLUMN_AUTORUN_PIXBUF, pixbuf, COLUMN_AUTORUN_NAME, _("Open Folder"), COLUMN_AUTORUN_APP_INFO, NULL, COLUMN_AUTORUN_X_CONTENT_TYPE, x_content_type, COLUMN_AUTORUN_ITEM_TYPE, AUTORUN_OPEN_FOLDER, -1); g_object_unref (pixbuf); gtk_list_store_append (list_store, &iter); gtk_list_store_set (list_store, &iter, COLUMN_AUTORUN_PIXBUF, NULL, COLUMN_AUTORUN_NAME, NULL, COLUMN_AUTORUN_APP_INFO, NULL, COLUMN_AUTORUN_X_CONTENT_TYPE, NULL, COLUMN_AUTORUN_ITEM_TYPE, AUTORUN_SEP, -1); for (l = app_info_list, n = include_ask ? 4 : 3; l != NULL; l = l->next, n++) { GIcon *icon; CajaIconInfo *icon_info; char *open_string; GAppInfo *app_info = l->data; /* we deliberately ignore should_show because some apps might want * to install special handlers that should be hidden in the regular * application launcher menus */ icon = g_app_info_get_icon (app_info); icon_info = caja_icon_info_lookup (icon, icon_size); pixbuf = caja_icon_info_get_pixbuf_at_size (icon_info, icon_size); g_object_unref (icon_info); open_string = g_strdup_printf (_("Open %s"), g_app_info_get_display_name (app_info)); gtk_list_store_append (list_store, &iter); gtk_list_store_set (list_store, &iter, COLUMN_AUTORUN_PIXBUF, pixbuf, COLUMN_AUTORUN_NAME, open_string, COLUMN_AUTORUN_APP_INFO, app_info, COLUMN_AUTORUN_X_CONTENT_TYPE, x_content_type, COLUMN_AUTORUN_ITEM_TYPE, AUTORUN_APP, -1); if (pixbuf != NULL) { g_object_unref (pixbuf); } g_free (open_string); if (g_app_info_equal (app_info, default_app_info)) { set_active = n; } } } if (include_open_with_other_app) { gtk_list_store_append (list_store, &iter); gtk_list_store_set (list_store, &iter, COLUMN_AUTORUN_PIXBUF, NULL, COLUMN_AUTORUN_NAME, NULL, COLUMN_AUTORUN_APP_INFO, NULL, COLUMN_AUTORUN_X_CONTENT_TYPE, NULL, COLUMN_AUTORUN_ITEM_TYPE, AUTORUN_SEP, -1); gtk_list_store_append (list_store, &iter); pixbuf = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), "application-x-executable", icon_size, 0, NULL); gtk_list_store_set (list_store, &iter, COLUMN_AUTORUN_PIXBUF, pixbuf, COLUMN_AUTORUN_NAME, _("Open with other Application..."), COLUMN_AUTORUN_APP_INFO, NULL, COLUMN_AUTORUN_X_CONTENT_TYPE, x_content_type, COLUMN_AUTORUN_ITEM_TYPE, AUTORUN_OTHER_APP, -1); g_object_unref (pixbuf); } if (default_app_info != NULL) { g_object_unref (default_app_info); } g_list_foreach (app_info_list, (GFunc) g_object_unref, NULL); g_list_free(app_info_list); gtk_combo_box_set_model (GTK_COMBO_BOX (combo_box), GTK_TREE_MODEL (list_store)); g_object_unref (G_OBJECT (list_store)); gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo_box)); renderer = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), renderer, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), renderer, "pixbuf", COLUMN_AUTORUN_PIXBUF, NULL); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), renderer, "text", COLUMN_AUTORUN_NAME, NULL); gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (combo_box), combo_box_separator_func, NULL, NULL); if (num_apps == 0) { gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), 0); gtk_widget_set_sensitive (combo_box, FALSE); } else { gtk_widget_set_sensitive (combo_box, TRUE); if (pref_ask && include_ask) { gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), 0); } else if (pref_ignore) { gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), include_ask ? 1 : 0); } else if (pref_open_folder) { gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), include_ask ? 2 : 1); } else if (set_active != -1) { gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), set_active); } else { gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), include_ask ? 1 : 0); } /* See if we have an old data around */ data = g_object_get_data (G_OBJECT (combo_box), "caja_autorun_combobox_data"); if (data) { new_data = FALSE; g_free (data->x_content_type); } else { data = g_new0 (CajaAutorunComboBoxData, 1); } data->x_content_type = g_strdup (x_content_type); data->include_ask = include_ask; data->include_open_with_other_app = include_open_with_other_app; data->update_settings = update_settings; data->changed_cb = changed_cb; data->user_data = user_data; data->combo_box = combo_box; if (data->changed_signal_id == 0) { data->changed_signal_id = g_signal_connect (G_OBJECT (combo_box), "changed", G_CALLBACK (combo_box_changed), data); } } if (new_data) { g_object_set_data_full (G_OBJECT (combo_box), "caja_autorun_combobox_data", data, (GDestroyNotify) caja_autorun_combobox_data_destroy); } }
char * mpl_gdk_windowing_get_startup_notify_id (GAppLaunchContext *context, GAppInfo *info, GList *files) { static int sequence = 0; #if 0 GdkAppLaunchContextPrivate *priv; #endif GdkDisplay *display; GdkScreen *screen; int files_count; char *description; char *icon_name; const char *binary_name; const char *application_id; char *screen_str; char *workspace_str; #if 0 GIcon *icon; #endif guint32 timestamp; char *startup_id; #if 0 priv = GDK_APP_LAUNCH_CONTEXT (context)->priv; if (priv->screen) { screen = priv->screen; display = gdk_screen_get_display (priv->screen); } else if (priv->display) { display = priv->display; screen = gdk_display_get_default_screen (display); } else { display = gdk_display_get_default (); screen = gdk_display_get_default_screen (display); } #else display = gdk_display_get_default (); screen = gdk_display_get_default_screen (display); #endif files_count = g_list_length (files); if (files_count == 0) description = g_strdup_printf (_("Starting %s"), g_app_info_get_name (info)); else if (files_count == 1) description = g_strdup_printf (_("Opening %s"), get_display_name (files->data)); else description = g_strdup_printf (g_dngettext (GETTEXT_PACKAGE, "Opening %d Item", "Opening %d Items", files_count), files_count); icon_name = NULL; #if 0 if (priv->icon_name) icon_name = g_strdup (priv->icon_name); else { icon = NULL; if (priv->icon != NULL) icon = g_object_ref (priv->icon); else if (files_count == 1) icon = get_icon (files->data); if (icon == NULL) { icon = g_app_info_get_icon (info); g_object_ref (icon); } if (icon) icon_name = gicon_to_string (icon); g_object_unref (icon); } #endif binary_name = g_app_info_get_executable (info); #if 0 timestamp = priv->timestamp; if (timestamp == GDK_CURRENT_TIME) #endif timestamp = gdk_x11_display_get_user_time (display); screen_str = g_strdup_printf ("%d", gdk_screen_get_number (screen)); #if 0 if (priv->workspace > -1) workspace_str = g_strdup_printf ("%d", priv->workspace); else #endif workspace_str = NULL; if (G_IS_DESKTOP_APP_INFO (info)) application_id = g_desktop_app_info_get_filename (G_DESKTOP_APP_INFO (info)); else application_id = NULL; startup_id = g_strdup_printf ("%s-%lu-%s-%s-%d_TIME%lu", g_get_prgname (), (unsigned long)getpid (), g_get_host_name (), binary_name, sequence++, (unsigned long)timestamp); gdk_x11_display_broadcast_startup_message (display, "new", "ID", startup_id, "NAME", g_app_info_get_name (info), "SCREEN", screen_str, "BIN", binary_name, "ICON", icon_name, "DESKTOP", workspace_str, "DESCRIPTION", description, "WMCLASS", NULL, /* FIXME */ "APPLICATION_ID", application_id, NULL); g_free (description); g_free (screen_str); g_free (workspace_str); g_free (icon_name); add_startup_timeout (screen, startup_id); return startup_id; }
/* create the "open with" dialog. */ void dlg_open_with (FrWindow *window, GList *file_list) { DialogData *data; GAppInfo *app; GList *scan, *app_names = NULL; char **editors; int i; GtkWidget *cancel_button; GtkTreeIter iter; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkIconTheme *theme; int icon_size; if (file_list == NULL) return; data = g_new0 (DialogData, 1); data->settings = g_settings_new (EXRED_SCHEMA_GENERAL); data->builder = _gtk_builder_new_from_file ("open-with.ui"); if (data->builder == NULL) { g_free (data); return; } data->file_list = path_list_dup (file_list); data->window = window; /* Get the widgets. */ data->dialog = _gtk_builder_get_widget (data->builder, "open_with_dialog"); data->o_app_tree_view = _gtk_builder_get_widget (data->builder, "o_app_list_tree_view"); data->o_recent_tree_view = _gtk_builder_get_widget (data->builder, "o_recent_tree_view"); data->o_app_entry = _gtk_builder_get_widget (data->builder, "o_app_entry"); data->o_del_button = _gtk_builder_get_widget (data->builder, "o_del_button"); data->ok_button = _gtk_builder_get_widget (data->builder, "o_ok_button"); cancel_button = _gtk_builder_get_widget (data->builder, "o_cancel_button"); gtk_widget_set_sensitive (data->ok_button, FALSE); /* Set the signals handlers. */ g_signal_connect (G_OBJECT (data->dialog), "destroy", G_CALLBACK (open_with__destroy_cb), data); g_signal_connect (G_OBJECT (data->o_app_entry), "changed", G_CALLBACK (app_entry__changed_cb), data); g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (data->o_app_tree_view))), "changed", G_CALLBACK (app_list_selection_changed_cb), data); g_signal_connect (G_OBJECT (data->o_app_tree_view), "row_activated", G_CALLBACK (app_activated_cb), data); g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (data->o_recent_tree_view))), "changed", G_CALLBACK (recent_list_selection_changed_cb), data); g_signal_connect (G_OBJECT (data->o_recent_tree_view), "row_activated", G_CALLBACK (recent_activated_cb), data); g_signal_connect (G_OBJECT (data->ok_button), "clicked", G_CALLBACK (open_cb), data); g_signal_connect_swapped (G_OBJECT (cancel_button), "clicked", G_CALLBACK (gtk_widget_destroy), G_OBJECT (data->dialog)); g_signal_connect (G_OBJECT (data->o_del_button), "clicked", G_CALLBACK (delete_recent_cb), data); /* Set data. */ /* * registered applications list. */ data->app_list = NULL; for (scan = data->file_list; scan; scan = scan->next) { const char *mime_type; const char *name = scan->data; mime_type = get_file_mime_type_for_path (name, FALSE); if ((mime_type != NULL) && ! g_content_type_is_unknown (mime_type)) data->app_list = g_list_concat (data->app_list, g_app_info_get_all_for_type (mime_type)); } data->app_model = GTK_TREE_MODEL (gtk_list_store_new (N_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_POINTER)); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (data->app_model), TEXT_COLUMN, GTK_SORT_ASCENDING); gtk_tree_view_set_model (GTK_TREE_VIEW (data->o_app_tree_view), data->app_model); g_object_unref (G_OBJECT (data->app_model)); theme = gtk_icon_theme_get_default (); icon_size = get_folder_pixbuf_size_for_list (GTK_WIDGET (data->dialog)); for (scan = data->app_list; scan; scan = scan->next) { gboolean found; char *utf8_name; GdkPixbuf *icon_image = NULL; app = scan->data; found = FALSE; if (app_names != NULL) { GList *p; for (p = app_names; p && !found; p = p->next) if (g_strcmp0 ((char*)p->data, g_app_info_get_executable (app)) == 0) found = TRUE; } if (found) continue; app_names = g_list_prepend (app_names, (char*) g_app_info_get_executable (app)); utf8_name = g_locale_to_utf8 (g_app_info_get_name (app), -1, NULL, NULL, NULL); icon_image = get_icon_pixbuf (g_app_info_get_icon (app), icon_size, theme); gtk_list_store_append (GTK_LIST_STORE (data->app_model), &iter); gtk_list_store_set (GTK_LIST_STORE (data->app_model), &iter, ICON_COLUMN, icon_image, TEXT_COLUMN, utf8_name, DATA_COLUMN, app, -1); g_free (utf8_name); } column = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "pixbuf", ICON_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "text", TEXT_COLUMN, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (data->o_app_tree_view), column); if (app_names) g_list_free (app_names); /* * recent editors list. */ data->recent_model = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_STRING)); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (data->recent_model), 0, GTK_SORT_ASCENDING); gtk_tree_view_set_model (GTK_TREE_VIEW (data->o_recent_tree_view), data->recent_model); g_object_unref (G_OBJECT (data->recent_model)); editors = g_settings_get_strv (data->settings, PREF_GENERAL_EDITORS); for (i = 0; editors[i] != NULL; i++) { gtk_list_store_append (GTK_LIST_STORE (data->recent_model), &iter); gtk_list_store_set (GTK_LIST_STORE (data->recent_model), &iter, 0, editors[i], -1); } g_strfreev (editors); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (NULL, renderer, "text", 0, NULL); gtk_tree_view_column_set_sort_column_id (column, 0); gtk_tree_view_append_column (GTK_TREE_VIEW (data->o_recent_tree_view), column); /* Run dialog. */ gtk_window_set_transient_for (GTK_WINDOW (data->dialog), GTK_WINDOW (window)); gtk_window_set_modal (GTK_WINDOW (data->dialog), TRUE); gtk_widget_show_all (data->dialog); }
static void _gth_browser_update_open_menu (GthBrowser *browser, const char *path) { GtkWidget *openwith_item; GtkWidget *menu; GList *items; GList *file_list; GList *scan; GList *appinfo_list; GHashTable *used_mime_types; GthIconCache *icon_cache; GHashTable *used_apps; openwith_item = gtk_ui_manager_get_widget (gth_browser_get_ui_manager (browser), path); menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (openwith_item)); _gtk_container_remove_children (GTK_CONTAINER (menu), NULL, NULL); items = gth_file_selection_get_selected (GTH_FILE_SELECTION (gth_browser_get_file_list_view (browser))); file_list = gth_file_list_get_files (GTH_FILE_LIST (gth_browser_get_file_list (browser)), items); appinfo_list = NULL; used_mime_types = g_hash_table_new (g_str_hash, g_str_equal); for (scan = file_list; scan; scan = scan->next) { GthFileData *file_data = scan->data; const char *mime_type; mime_type = gth_file_data_get_mime_type (file_data); if ((mime_type == NULL) || g_content_type_is_unknown (mime_type)) continue; if (g_hash_table_lookup (used_mime_types, mime_type) != NULL) continue; appinfo_list = g_list_concat (appinfo_list, g_app_info_get_all_for_type (mime_type)); g_hash_table_insert (used_mime_types, (gpointer) mime_type, GINT_TO_POINTER (1)); } g_hash_table_destroy (used_mime_types); icon_cache = gth_browser_get_menu_icon_cache (browser); used_apps = g_hash_table_new (g_str_hash, g_str_equal); for (scan = appinfo_list; scan; scan = scan->next) { GAppInfo *appinfo = scan->data; char *label; GtkWidget *menu_item; GIcon *icon; if (strcmp (g_app_info_get_executable (appinfo), "pix") == 0) continue; if (g_hash_table_lookup (used_apps, g_app_info_get_id (appinfo)) != NULL) continue; g_hash_table_insert (used_apps, (gpointer) g_app_info_get_id (appinfo), GINT_TO_POINTER (1)); label = g_strdup_printf ("%s", g_app_info_get_name (appinfo)); menu_item = gtk_image_menu_item_new_with_label (label); icon = g_app_info_get_icon (appinfo); if (icon != NULL) { GdkPixbuf *pixbuf; pixbuf = gth_icon_cache_get_pixbuf (icon_cache, icon); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), gtk_image_new_from_pixbuf (pixbuf)); gtk_image_menu_item_set_always_show_image (GTK_IMAGE_MENU_ITEM (menu_item), TRUE); g_object_unref (pixbuf); } gtk_widget_show (menu_item); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item); g_object_set_data_full (G_OBJECT (menu_item), "appinfo", g_object_ref (appinfo), g_object_unref); g_signal_connect (menu_item, "activate", G_CALLBACK (activate_open_with_application_item), browser); g_free (label); } /* if (appinfo_list == NULL) { GtkWidget *menu_item; menu_item = gtk_image_menu_item_new_with_label (_("No application available")); gtk_widget_set_sensitive (menu_item, FALSE); gtk_widget_show (menu_item); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item); }*/ gtk_widget_set_sensitive (openwith_item, appinfo_list != NULL); gtk_widget_show (openwith_item); g_hash_table_destroy (used_apps); _g_object_list_unref (appinfo_list); _g_object_list_unref (file_list); _gtk_tree_path_list_free (items); }
static void fill_open_with_menu (GtkTreeView *view, GtkBuilder *builder, GtkTreePath *path) { GtkTreeModel *model = gtk_tree_view_get_model (view); if (!model) { return; } GtkTreeIter iter; if (!gtk_tree_model_get_iter(model, &iter, path)) { return; } DatabaseSearchEntry *entry = (DatabaseSearchEntry *)iter.user_data; if (!entry) { return; } BTreeNode * node = db_search_entry_get_node (entry); GList *app_list = NULL; char *content_type = NULL; if (node->is_dir) { content_type = g_content_type_from_mime_type ("inode/directory"); } else { content_type = g_content_type_guess (node->name, NULL, 0, NULL); } if (!content_type) { goto clean_up; } app_list = g_app_info_get_all_for_type (content_type); if (!app_list) { goto clean_up; } GMenu *menu_mime = G_MENU (gtk_builder_get_object (builder, "fsearch_listview_menu_open_with_mime_section")); for (GList *list_iter = app_list; list_iter; list_iter = list_iter->next) { GAppInfo *app_info = list_iter->data; const char *display_name = g_app_info_get_display_name (app_info); const char *app_id = g_app_info_get_id (app_info); char detailed_action[1024] = ""; snprintf (detailed_action, sizeof (detailed_action), "win.open_with('%s')", app_id); GMenuItem *menu_item = g_menu_item_new (display_name, detailed_action); g_menu_item_set_icon (menu_item, g_app_info_get_icon (app_info)); g_menu_append_item (menu_mime, menu_item); g_object_unref (menu_item); } clean_up: if (content_type) { g_free (content_type); content_type = NULL; } if (app_list) { g_list_free_full (app_list, g_object_unref); app_list = NULL; } }
static CoglHandle cinnamon_app_create_faded_icon_cpu (StTextureCache *cache, const char *key, void *datap, GError **error) { CreateFadedIconData *data = datap; CinnamonApp *app; GdkPixbuf *pixbuf; int size; int scale; CoglHandle texture; gint width, height, rowstride; guint8 n_channels; gboolean have_alpha; gint fade_start; gint fade_range; guint i, j; guint pixbuf_byte_size; guint8 *orig_pixels; guint8 *pixels; GIcon *icon; GtkIconInfo *info; app = data->app; size = data->size; scale = data->scale; info = NULL; icon = g_app_info_get_icon (G_APP_INFO (gmenu_tree_entry_get_app_info (app->entry))); if (icon != NULL) { info = gtk_icon_theme_lookup_by_gicon_for_scale (gtk_icon_theme_get_default (), icon, size, scale, GTK_ICON_LOOKUP_FORCE_SIZE); } if (info == NULL) { icon = g_themed_icon_new ("application-x-executable"); info = gtk_icon_theme_lookup_by_gicon_for_scale (gtk_icon_theme_get_default (), icon, size, scale, GTK_ICON_LOOKUP_FORCE_SIZE); g_object_unref (icon); } if (info == NULL) return COGL_INVALID_HANDLE; pixbuf = gtk_icon_info_load_icon (info, NULL); g_object_unref (info); if (pixbuf == NULL) return COGL_INVALID_HANDLE; width = gdk_pixbuf_get_width (pixbuf); height = gdk_pixbuf_get_height (pixbuf); rowstride = gdk_pixbuf_get_rowstride (pixbuf); n_channels = gdk_pixbuf_get_n_channels (pixbuf); orig_pixels = gdk_pixbuf_get_pixels (pixbuf); have_alpha = gdk_pixbuf_get_has_alpha (pixbuf); pixbuf_byte_size = (height - 1) * rowstride + + width * ((n_channels * gdk_pixbuf_get_bits_per_sample (pixbuf) + 7) / 8); pixels = g_malloc0 (rowstride * height); memcpy (pixels, orig_pixels, pixbuf_byte_size); fade_start = width / 2; fade_range = width - fade_start; for (i = fade_start; i < width; i++) { for (j = 0; j < height; j++) { guchar *pixel = &pixels[j * rowstride + i * n_channels]; float fade = 1.0 - ((float) i - fade_start) / fade_range; pixel[0] = 0.5 + pixel[0] * fade; pixel[1] = 0.5 + pixel[1] * fade; pixel[2] = 0.5 + pixel[2] * fade; if (have_alpha) pixel[3] = 0.5 + pixel[3] * fade; } } texture = st_cogl_texture_new_from_data_wrapper (width, height, COGL_TEXTURE_NONE, have_alpha ? COGL_PIXEL_FORMAT_RGBA_8888 : COGL_PIXEL_FORMAT_RGB_888, COGL_PIXEL_FORMAT_ANY, rowstride, pixels); g_free (pixels); g_object_unref (pixbuf); return texture; }
void nautilus_x_content_bar_set_x_content_type (NautilusXContentBar *bar, const char *x_content_type) { char *message; char *description; GAppInfo *default_app; g_free (bar->priv->x_content_type); bar->priv->x_content_type = g_strdup (x_content_type); description = g_content_type_get_description (x_content_type); /* Customize greeting for well-known x-content types */ if (strcmp (x_content_type, "x-content/audio-cdda") == 0) { message = g_strdup (_("These files are on an Audio CD.")); } else if (strcmp (x_content_type, "x-content/audio-dvd") == 0) { message = g_strdup (_("These files are on an Audio DVD.")); } else if (strcmp (x_content_type, "x-content/video-dvd") == 0) { message = g_strdup (_("These files are on a Video DVD.")); } else if (strcmp (x_content_type, "x-content/video-vcd") == 0) { message = g_strdup (_("These files are on a Video CD.")); } else if (strcmp (x_content_type, "x-content/video-svcd") == 0) { message = g_strdup (_("These files are on a Super Video CD.")); } else if (strcmp (x_content_type, "x-content/image-photocd") == 0) { message = g_strdup (_("These files are on a Photo CD.")); } else if (strcmp (x_content_type, "x-content/image-picturecd") == 0) { message = g_strdup (_("These files are on a Picture CD.")); } else if (strcmp (x_content_type, "x-content/image-dcf") == 0) { message = g_strdup (_("The media contains digital photos.")); } else if (strcmp (x_content_type, "x-content/audio-player") == 0) { message = g_strdup (_("These files are on a digital audio player.")); } else if (strcmp (x_content_type, "x-content/software") == 0) { message = g_strdup (_("The media contains software.")); } else { /* fallback to generic greeting */ message = g_strdup_printf (_("The media has been detected as \"%s\"."), description); } gtk_label_set_text (GTK_LABEL (bar->priv->label), message); gtk_widget_show (bar->priv->label); /* TODO: We really need a GtkBrowserBackButton-ish widget here.. until then, we only * show the default application. */ default_app = g_app_info_get_default_for_type (x_content_type, FALSE); if (default_app != NULL) { char *button_text; const char *name; GIcon *icon; GtkWidget *image; icon = g_app_info_get_icon (default_app); if (icon != NULL) { GdkPixbuf *pixbuf; int icon_size; NautilusIconInfo *icon_info; icon_size = nautilus_get_icon_size_for_stock_size (GTK_ICON_SIZE_BUTTON); icon_info = nautilus_icon_info_lookup (icon, icon_size); pixbuf = nautilus_icon_info_get_pixbuf_at_size (icon_info, icon_size); image = gtk_image_new_from_pixbuf (pixbuf); g_object_unref (pixbuf); g_object_unref (icon_info); } else { image = NULL; } name = g_app_info_get_name (default_app); button_text = g_strdup_printf (_("Open %s"), name); gtk_button_set_image (GTK_BUTTON (bar->priv->button), image); gtk_button_set_label (GTK_BUTTON (bar->priv->button), button_text); gtk_widget_show (bar->priv->button); g_free (button_text); g_object_unref (default_app); } else { gtk_widget_hide (bar->priv->button); } g_free (message); g_free (description); }
static void fill_combo_box(GtkIconTheme* theme, GtkComboBox* combo_box, GList* app_list, gchar* mime) { guint index = 0; GList* entry; GtkTreeModel* model; GtkCellRenderer* renderer; GtkTreeIter iter; GdkPixbuf* pixbuf; GAppInfo* default_app; default_app = NULL; if (g_strcmp0(mime, "terminal") == 0) { GSettings *terminal_settings = g_settings_new (TERMINAL_SCHEMA); gchar *default_terminal = g_settings_get_string (terminal_settings, TERMINAL_KEY); for (entry = app_list; entry != NULL; entry = g_list_next(entry)) { GAppInfo* item = (GAppInfo*) entry->data; if (g_strcmp0 (g_app_info_get_executable (item), default_terminal) == 0) { default_app = item; } } g_free (default_terminal); g_object_unref (terminal_settings); } else if (g_strcmp0(mime, "visual") == 0) { GSettings *visual_settings = g_settings_new (VISUAL_SCHEMA); gchar *default_visual = g_settings_get_string (visual_settings, VISUAL_KEY); for (entry = app_list; entry != NULL; entry = g_list_next(entry)) { GAppInfo* item = (GAppInfo*) entry->data; if (g_strcmp0 (g_app_info_get_executable (item), default_visual) == 0) { default_app = item; } } g_free (default_visual); g_object_unref (visual_settings); } else if (g_strcmp0(mime, "mobility") == 0) { GSettings *mobility_settings = g_settings_new (MOBILITY_SCHEMA); gchar *default_mobility = g_settings_get_string (mobility_settings, MOBILITY_KEY); for (entry = app_list; entry != NULL; entry = g_list_next(entry)) { GAppInfo* item = (GAppInfo*) entry->data; if (g_strcmp0 (g_app_info_get_executable (item), default_mobility) == 0) { default_app = item; } } g_free (default_mobility); g_object_unref (mobility_settings); } else { default_app = g_app_info_get_default_for_type (mime, FALSE); } if (theme == NULL) { theme = gtk_icon_theme_get_default(); } model = GTK_TREE_MODEL(gtk_list_store_new(4, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING)); gtk_combo_box_set_model(combo_box, model); renderer = gtk_cell_renderer_pixbuf_new(); /* Not all cells have a pixbuf, this prevents the combo box to shrink */ gtk_cell_renderer_set_fixed_size(renderer, -1, 22); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo_box), renderer, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo_box), renderer, "pixbuf", PIXBUF_COL, NULL); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo_box), renderer, TRUE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo_box), renderer, "text", TEXT_COL, NULL); for (entry = app_list; entry != NULL; entry = g_list_next(entry)) { GAppInfo* item = (GAppInfo*) entry->data; /* Icon */ GIcon* icon = g_app_info_get_icon(item); gchar* icon_name = g_icon_to_string(icon); if (icon_name == NULL) { /* Default icon */ icon_name = g_strdup("binary"); } pixbuf = gtk_icon_theme_load_icon(theme, icon_name, 22, 0, NULL); gtk_list_store_append(GTK_LIST_STORE(model), &iter); gtk_list_store_set(GTK_LIST_STORE(model), &iter, PIXBUF_COL, pixbuf, TEXT_COL, g_app_info_get_display_name(item), ID_COL, g_app_info_get_id(item), ICONAME_COL, icon_name, -1); if (pixbuf) { g_object_unref(pixbuf); } /* Set the index for the default app */ if (default_app != NULL && g_app_info_equal(item, default_app)) { gtk_combo_box_set_active(combo_box, index); } g_free(icon_name); index++; } }
static void search_panel_add_one_app_info (CcSearchPanel *self, GAppInfo *app_info, gboolean default_enabled) { GtkWidget *row, *box, *w; GIcon *icon; /* gnome-control-center is special cased in the shell, and is not configurable */ if (g_strcmp0 (g_app_info_get_id (app_info), "gnome-control-center.desktop") == 0) return; /* reset valignment of the list box */ gtk_widget_set_valign (self->priv->list_box, GTK_ALIGN_FILL); row = gtk_list_box_row_new (); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_container_add (GTK_CONTAINER (row), box); gtk_widget_set_hexpand (box, TRUE); gtk_container_set_border_width (GTK_CONTAINER (box), 6); g_object_set_data_full (G_OBJECT (row), "app-info", g_object_ref (app_info), g_object_unref); g_object_set_data (G_OBJECT (row), "self", self); gtk_container_add (GTK_CONTAINER (self->priv->list_box), row); icon = g_app_info_get_icon (app_info); if (icon == NULL) icon = g_themed_icon_new ("application-x-executable"); else g_object_ref (icon); w = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_DIALOG); gtk_container_add (GTK_CONTAINER (box), w); g_object_unref (icon); w = gtk_label_new (g_app_info_get_name (app_info)); gtk_container_add (GTK_CONTAINER (box), w); w = gtk_switch_new (); gtk_widget_set_valign (w, GTK_ALIGN_CENTER); gtk_box_pack_end (GTK_BOX (box), w, FALSE, FALSE, 0); if (default_enabled) { g_settings_bind_with_mapping (self->priv->search_settings, "disabled", w, "active", G_SETTINGS_BIND_DEFAULT, switch_settings_mapping_get_default_enabled, switch_settings_mapping_set_default_enabled, row, NULL); } else { g_settings_bind_with_mapping (self->priv->search_settings, "enabled", w, "active", G_SETTINGS_BIND_DEFAULT, switch_settings_mapping_get_default_disabled, switch_settings_mapping_set_default_disabled, row, NULL); } gtk_widget_show_all (row); }
void resolve_item_order(pqi inst) { /* Remove the old icon images; we're about to replace them. */ if (inst->pmainicon) g_object_unref(inst->pmainicon); if (inst->pmainicon_glow) g_object_unref(inst->pmainicon_glow); if (inst->items != NULL) /* We've got sorting to do */ { /* This uses a very simple, O(N**2) sorting method. I don't feel it calls for anything more complicated. */ psi iter, back, move; switch (inst->mode) /* What are we sorting by? */ { case mode_static: for (iter = inst->items; iter != NULL; iter = iter->next) /* For each list item */ { move = NULL; for (back = iter->prev; back != NULL; back = back->prev) /* For each behind us */ if (back->id > iter->id) /* If it has a higher ID, move before it so the lowest id is first */ move = back; else break; if (move) listsort_move(inst,move,&iter); } break; case mode_recent: for (iter = inst->items; iter != NULL; iter = iter->next) /* For each list item */ { move = NULL; for (back = iter->prev; back != NULL; back = back->prev) /* For each behind us */ if (back->lastaccess < iter->lastaccess) /* If the previous one was used earlier, move before it so the most recent is first */ move = back; else break; if (move) listsort_move(inst,move,&iter); } break; case mode_unrecent: for (iter = inst->items; iter != NULL; iter = iter->next) /* For each list item */ { move = NULL; for (back = iter->prev; back != NULL; back = back->prev) /* For each behind us */ if (back->lastaccess > iter->lastaccess) /* If the previous one was used later, move before it so the least recent is first */ move = back; else break; if (move) listsort_move(inst,move,&iter); } break; case mode_infrequent: for (iter = inst->items; iter != NULL; iter = iter->next) /* For each list item */ { move = NULL; for (back = iter->prev; back != NULL; back = back->prev) /* For each behind us */ if (back->uses > iter->uses) /* If it was used more times, move before it so the least used comes first */ move = back; else break; if (move) listsort_move(inst,move,&iter); } break; case mode_frequent: for (iter = inst->items; iter != NULL; iter = iter->next) /* For each list item */ { move = NULL; for (back = iter->prev; back != NULL; back = back->prev) /* For each behind us */ if (back->uses < iter->uses) /* If it was used less times, move before it so the most used comes first */ move = back; else break; if (move) listsort_move(inst,move,&iter); } break; } /* Resolve the icon */ if (inst->items->dfile) { GIcon *ico = g_app_info_get_icon(G_APP_INFO(inst->items->dfile)); if (ico) icon_gicon(inst,ico,inst->size); else icon_default(inst,inst->size); } else icon_default(inst,inst->size); } else icon_default(inst,inst->size); gtk_widget_queue_draw(inst->box); }