/* * Function to use anywhere in the application to send a message to the LogList */ void Log_Print (Log_Error_Type error_type, gchar const *format, ...) { va_list args; gchar *string; GtkTreeIter iter; static gboolean first_time = TRUE; static gchar *file_path = NULL; GFile *file; GFileOutputStream *file_ostream; GError *error = NULL; va_start (args, format); string = g_strdup_vprintf(format, args); va_end (args); // If the log window is displayed then messages are displayed, else // the messages are stored in a temporary list. if (LogList && logListModel) { gint n_items; gchar *time = Log_Format_Date(); /* Remove lines that exceed the limit. */ n_items = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (logListModel), NULL); if (n_items > LOG_MAX_LINES - 1 && gtk_tree_model_get_iter_first(GTK_TREE_MODEL(logListModel), &iter)) { gtk_list_store_remove(GTK_LIST_STORE(logListModel), &iter); } gtk_list_store_insert_with_values (logListModel, &iter, G_MAXINT, LOG_PIXBUF, Log_Get_Stock_Id_From_Error_Type (error_type), LOG_TIME_TEXT, time, LOG_TEXT, string, LOG_ROW_BACKGROUND, NULL, LOG_ROW_FOREGROUND, NULL, -1); Log_List_Set_Row_Visible(GTK_TREE_MODEL(logListModel), &iter); g_free(time); }else { Log_Data *LogData = g_malloc0(sizeof(Log_Data)); LogData->time = Log_Format_Date(); LogData->error_type = error_type; LogData->string = g_strdup(string); LogPrintTmpList = g_list_append(LogPrintTmpList,LogData); //g_print("%s",string); } // Store also the messages in the log file. if (!file_path) { gchar *cache_path = g_build_filename (g_get_user_cache_dir (), PACKAGE_TARNAME, NULL); if (!g_file_test (cache_path, G_FILE_TEST_IS_DIR)) { gint result = g_mkdir_with_parents (cache_path, S_IRWXU); if (result == -1) { g_printerr ("%s", "Unable to create cache directory"); g_free (cache_path); g_free (string); return; } } file_path = g_build_filename (cache_path, LOG_FILE, NULL); g_free (cache_path); } file = g_file_new_for_path (file_path); /* On startup, the log is cleared. The log is then appended to for the * remainder of the application lifetime. */ if (first_time) { file_ostream = g_file_replace (file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, &error); } else { file_ostream = g_file_append_to (file, G_FILE_CREATE_NONE, NULL, &error); } if (file_ostream) { gchar *time; GString *data; gsize bytes_written; time = Log_Format_Date (); data = g_string_new (time); g_free (time); data = g_string_append_c (data, ' '); data = g_string_append (data, string); g_free (string); data = g_string_append_c (data, '\n'); if (!g_output_stream_write_all (G_OUTPUT_STREAM (file_ostream), data->str, data->len, &bytes_written, NULL, &error)) { g_debug ("Only %" G_GSIZE_FORMAT " bytes out of %" G_GSIZE_FORMAT "bytes of data were written", bytes_written, data->len); /* To avoid recursion of Log_Print. */ g_warning ("Error writing to the log file '%s' ('%s')", file_path, error->message); g_error_free (error); g_string_free (data, TRUE); g_object_unref (file_ostream); g_object_unref (file); return; } first_time = FALSE; g_string_free (data, TRUE); } else { g_warning ("Error opening output stream of file '%s' ('%s')", file_path, error->message); g_error_free (error); } g_object_unref (file_ostream); g_object_unref (file); }
static void account_widget_irc_setup (EmpathyAccountWidgetIrc *settings) { gchar *nick = NULL; gchar *fullname = NULL; gchar *server = NULL; gint port = 6667; gchar *charset; gboolean ssl = FALSE; EmpathyIrcNetwork *network = NULL; mc_account_get_param_string (settings->account, "account", &nick); mc_account_get_param_string (settings->account, "fullname", &fullname); mc_account_get_param_string (settings->account, "server", &server); mc_account_get_param_string (settings->account, "charset", &charset); mc_account_get_param_int (settings->account, "port", &port); mc_account_get_param_boolean (settings->account, "use-ssl", &ssl); if (!nick) { nick = g_strdup (g_get_user_name ()); mc_account_set_param_string (settings->account, "account", nick); } if (!fullname) { fullname = g_strdup (g_get_real_name ()); if (!fullname) { fullname = g_strdup (nick); } mc_account_set_param_string (settings->account, "fullname", fullname); } if (server != NULL) { GtkListStore *store; network = empathy_irc_network_manager_find_network_by_address ( settings->network_manager, server); store = GTK_LIST_STORE (gtk_combo_box_get_model ( GTK_COMBO_BOX (settings->combobox_network))); if (network != NULL) { gchar *name; g_object_set (network, "charset", charset, NULL); g_object_get (network, "name", &name, NULL); DEBUG ("Account use network %s", name); g_free (name); } else { /* We don't have this network. Let's create it */ EmpathyIrcServer *srv; GtkTreeIter iter; DEBUG ("Create a network %s", server); network = empathy_irc_network_new (server); srv = empathy_irc_server_new (server, port, ssl); empathy_irc_network_append_server (network, srv); empathy_irc_network_manager_add (settings->network_manager, network); gtk_list_store_insert_with_values (store, &iter, -1, COL_NETWORK_OBJ, network, COL_NETWORK_NAME, server, -1); gtk_combo_box_set_active_iter ( GTK_COMBO_BOX (settings->combobox_network), &iter); g_object_unref (srv); g_object_unref (network); } } fill_networks_model (settings, network); g_free (nick); g_free (fullname); g_free (server); g_free (charset); }
static void prepare_list (AppearanceData *data, GtkWidget *list, ThemeType type, GCallback callback) { GtkListStore *store; GList *l, *themes = NULL; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeModel *sort_model; GdkPixbuf *thumbnail; const gchar *key; ThumbnailGenFunc generator; ThemeThumbnailFunc thumb_cb; ThemeConvData *conv_data; GSettings *settings; switch (type) { case THEME_TYPE_GTK: themes = mate_theme_info_find_by_type (MATE_THEME_GTK_2); thumbnail = data->gtk_theme_icon; settings = data->interface_settings; key = GTK_THEME_KEY; generator = (ThumbnailGenFunc) generate_gtk_theme_thumbnail_async; thumb_cb = (ThemeThumbnailFunc) gtk_theme_thumbnail_cb; break; case THEME_TYPE_WINDOW: themes = mate_theme_info_find_by_type (MATE_THEME_MARCO); thumbnail = data->window_theme_icon; settings = data->marco_settings; key = MARCO_THEME_KEY; generator = (ThumbnailGenFunc) generate_marco_theme_thumbnail_async; thumb_cb = (ThemeThumbnailFunc) marco_theme_thumbnail_cb; break; case THEME_TYPE_ICON: themes = mate_theme_icon_info_find_all (); thumbnail = data->icon_theme_icon; settings = data->interface_settings; key = ICON_THEME_KEY; generator = (ThumbnailGenFunc) generate_icon_theme_thumbnail_async; thumb_cb = (ThemeThumbnailFunc) icon_theme_thumbnail_cb; break; case THEME_TYPE_CURSOR: themes = mate_theme_cursor_info_find_all (); thumbnail = NULL; settings = data->mouse_settings; key = CURSOR_THEME_KEY; generator = NULL; thumb_cb = NULL; break; default: /* we don't deal with any other type of themes here */ return; } store = gtk_list_store_new (NUM_COLS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING); for (l = themes; l; l = g_list_next (l)) { MateThemeCommonInfo *theme = (MateThemeCommonInfo *) l->data; GtkTreeIter i; if (type == THEME_TYPE_CURSOR) { thumbnail = ((MateThemeCursorInfo *) theme)->thumbnail; } else { generator (theme, thumb_cb, data, NULL); } gtk_list_store_insert_with_values (store, &i, 0, COL_LABEL, theme->readable_name, COL_NAME, theme->name, COL_THUMBNAIL, thumbnail, -1); if (type == THEME_TYPE_CURSOR && thumbnail) { g_object_unref (thumbnail); thumbnail = NULL; } } g_list_free (themes); sort_model = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (store)); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model), COL_LABEL, GTK_SORT_ASCENDING); if (type == THEME_TYPE_CURSOR) gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (sort_model), COL_LABEL, (GtkTreeIterCompareFunc) cursor_theme_sort_func, NULL, NULL); gtk_tree_view_set_model (GTK_TREE_VIEW (list), GTK_TREE_MODEL (sort_model)); renderer = gtk_cell_renderer_pixbuf_new (); g_object_set (renderer, "xpad", 3, "ypad", 3, NULL); column = gtk_tree_view_column_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_add_attribute (column, renderer, "pixbuf", COL_THUMBNAIL); gtk_tree_view_append_column (GTK_TREE_VIEW (list), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_add_attribute (column, renderer, "text", COL_LABEL); gtk_tree_view_append_column (GTK_TREE_VIEW (list), column); conv_data = g_new (ThemeConvData, 1); conv_data->data = data; conv_data->thumbnail = thumbnail; /* set useful data for callbacks */ g_object_set_data (G_OBJECT (list), THEME_DATA, conv_data); g_object_set_data (G_OBJECT (list), GSETTINGS_SETTINGS, settings); g_object_set_data (G_OBJECT (list), GSETTINGS_KEY, g_strdup(key)); /* select in treeview the theme set in gsettings */ GtkTreeModel *treemodel; treemodel = gtk_tree_view_get_model (GTK_TREE_VIEW (list)); gchar *theme = g_settings_get_string (settings, key); gchar *path = find_string_in_model (treemodel, theme, COL_NAME); if (path) { GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (list)); GtkTreePath *treepath = gtk_tree_path_new_from_string (path); gtk_tree_selection_select_path (selection, treepath); gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (list), treepath, NULL, FALSE, 0, 0); gtk_tree_path_free (treepath); g_free (path); } if (theme) g_free (theme); /* connect to gsettings change event */ gchar *signal_name = g_strdup_printf("changed::%s", key); g_signal_connect (settings, signal_name, G_CALLBACK (treeview_gsettings_changed_callback), list); g_free (signal_name); /* connect to treeview change event */ g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (list)), "changed", G_CALLBACK (treeview_selection_changed_callback), list); }
void fe_userlist_insert (session *sess, struct User *newuser, int row, int sel) { GtkTreeModel *model = sess->res->user_model; GdkPixbuf *pix = get_user_icon (sess->server, newuser); GtkTreeIter iter; char *nick; int nick_color = 0; if (prefs.pchat_away_track && newuser->away) nick_color = COL_AWAY; else if (prefs.pchat_gui_ulist_color) nick_color = text_color_of(newuser->nick); nick = newuser->nick; if (!prefs.pchat_gui_ulist_icons) { nick = malloc (strlen (newuser->nick) + 2); nick[0] = newuser->prefix[0]; if (!nick[0] || nick[0] == ' ') strcpy (nick, newuser->nick); else strcpy (nick + 1, newuser->nick); pix = NULL; } gtk_list_store_insert_with_values (GTK_LIST_STORE (model), &iter, row, COL_PIX, pix, COL_NICK, nick, COL_HOST, newuser->hostname, COL_USER, newuser, COL_GDKCOLOR, nick_color ? &colors[nick_color] : NULL, -1); if (!prefs.pchat_gui_ulist_icons) { free (nick); } /* is it me? */ if (newuser->me && sess->gui->nick_box) { if (!sess->gui->is_tab || sess == current_tab) mg_set_access_icon (sess->gui, pix, sess->server->is_away); } #if 0 if (prefs.hilitenotify && notify_isnotify (sess, newuser->nick)) { gtk_clist_set_foreground ((GtkCList *) sess->gui->user_clist, row, &colors[prefs.nu_color]); } #endif /* is it the front-most tab? */ if (gtk_tree_view_get_model (GTK_TREE_VIEW (sess->gui->user_tree)) == model) { if (sel) gtk_tree_selection_select_iter (gtk_tree_view_get_selection (GTK_TREE_VIEW (sess->gui->user_tree)), &iter); } }
gint main (gint argc, gchar ** argv) { GtkWidget *window, *box, *button, *hbox, *combo; GtkWidget *w2, *w3; GtkListStore* store; GtkWidget *tree_view; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkWidget *scrolled_win; int i; GtkTreeIter iter; gtk_init (&argc, &argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_widget_set_size_request (window, 300, 300); box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_add (GTK_CONTAINER (window), box); switcher = gtk_stack_switcher_new (); gtk_box_pack_start (GTK_BOX (box), switcher, FALSE, FALSE, 0); stack = gtk_stack_new (); /* Make transitions longer so we can see that they work */ gtk_stack_set_transition_duration (GTK_STACK (stack), 1500); gtk_widget_set_halign (stack, GTK_ALIGN_START); gtk_container_add (GTK_CONTAINER (box), stack); gtk_stack_switcher_set_stack (GTK_STACK_SWITCHER (switcher), GTK_STACK (stack)); w1 = gtk_text_view_new (); gtk_text_buffer_set_text (gtk_text_view_get_buffer (GTK_TEXT_VIEW (w1)), "This is a\nTest\nBalh!", -1); gtk_container_add_with_properties (GTK_CONTAINER (stack), w1, "name", "1", "title", "1", NULL); w2 = gtk_button_new_with_label ("Gazoooooooooooooooonk"); gtk_container_add (GTK_CONTAINER (stack), w2); gtk_container_child_set (GTK_CONTAINER (stack), w2, "name", "2", "title", "2", "needs-attention", TRUE, NULL); scrolled_win = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_size_request (scrolled_win, 100, 200); store = gtk_list_store_new (1, G_TYPE_STRING); for (i = 0; i < 40; i++) gtk_list_store_insert_with_values (store, &iter, i, 0, "Testvalule", -1); tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store)); gtk_container_add (GTK_CONTAINER (scrolled_win), tree_view); w3 = scrolled_win; renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Target", renderer, "text", 0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column); gtk_stack_add_titled (GTK_STACK (stack), w3, "3", "3"); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_container_add (GTK_CONTAINER (box), hbox); button = gtk_button_new_with_label ("1"); gtk_container_add (GTK_CONTAINER (hbox), button); g_signal_connect (button, "clicked", (GCallback) set_visible_child, w1); button = gtk_button_new_with_label ("2"); gtk_container_add (GTK_CONTAINER (hbox), button); g_signal_connect (button, "clicked", (GCallback) set_visible_child, w2); button = gtk_button_new_with_label ("3"); gtk_container_add (GTK_CONTAINER (hbox), button); g_signal_connect (button, "clicked", (GCallback) set_visible_child, w3); button = gtk_button_new_with_label ("1"); gtk_container_add (GTK_CONTAINER (hbox), button); g_signal_connect (button, "clicked", (GCallback) set_visible_child_name, (gpointer) "1"); button = gtk_button_new_with_label ("2"); gtk_container_add (GTK_CONTAINER (hbox), button); g_signal_connect (button, "clicked", (GCallback) set_visible_child_name, (gpointer) "2"); button = gtk_button_new_with_label ("3"); gtk_container_add (GTK_CONTAINER (hbox), button); g_signal_connect (button, "clicked", (GCallback) set_visible_child_name, (gpointer) "3"); button = gtk_check_button_new_with_label ("homogeneous"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), gtk_stack_get_homogeneous (GTK_STACK (stack))); gtk_container_add (GTK_CONTAINER (hbox), button); g_signal_connect (button, "clicked", (GCallback) toggle_homogeneous, NULL); button = gtk_toggle_button_new_with_label ("Add icon"); g_signal_connect (button, "toggled", (GCallback) toggle_icon_name, NULL); gtk_container_add (GTK_CONTAINER (hbox), button); combo = gtk_combo_box_text_new (); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "NONE"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "CROSSFADE"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "SLIDE_RIGHT"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "SLIDE_LEFT"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "SLIDE_UP"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "SLIDE_DOWN"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "SLIDE_LEFT_RIGHT"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "SLIDE_UP_DOWN"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "OVER_UP"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "OVER_DOWN"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "OVER_LEFT"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "OVER_RIGHT"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "UNDER_UP"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "UNDER_DOWN"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "UNDER_LEFT"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "UNDER_RIGHT"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "OVER_UP_DOWN"); gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 0); gtk_container_add (GTK_CONTAINER (hbox), combo); g_signal_connect (combo, "changed", (GCallback) toggle_transitions, NULL); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_container_add (GTK_CONTAINER (box), hbox); button = gtk_button_new_with_label ("<"); g_signal_connect (button, "clicked", (GCallback) on_back_button_clicked, stack); g_signal_connect (stack, "notify::visible-child-name", (GCallback)update_back_button_sensitivity, button); gtk_container_add (GTK_CONTAINER (hbox), button); button = gtk_button_new_with_label (">"); gtk_container_add (GTK_CONTAINER (hbox), button); g_signal_connect (button, "clicked", (GCallback) on_forward_button_clicked, stack); g_signal_connect (stack, "notify::visible-child-name", (GCallback)update_forward_button_sensitivity, button); gtk_widget_show_all (window); gtk_main (); gtk_widget_destroy (window); return 0; }
static void ft_manager_add_handler_to_list (EmpathyFTManager *manager, EmpathyFTHandler *handler, const GError *error) { GtkTreeRowReference *row_ref; GtkTreeIter iter; GtkTreeSelection *selection; GtkTreePath *path; GIcon *icon; const char *content_type, *second_line; char *first_line, *message; EmpathyFTManagerPriv *priv = GET_PRIV (manager); icon = NULL; /* get the icon name from the mime-type of the file. */ content_type = empathy_ft_handler_get_content_type (handler); if (content_type != NULL) icon = g_content_type_get_icon (content_type); /* append the handler in the store */ gtk_list_store_insert_with_values (GTK_LIST_STORE (priv->model), &iter, G_MAXINT, COL_FT_OBJECT, handler, COL_ICON, icon, -1); if (icon != NULL) g_object_unref (icon); /* insert the new row_ref in the hash table */ path = gtk_tree_model_get_path (GTK_TREE_MODEL (priv->model), &iter); row_ref = gtk_tree_row_reference_new (GTK_TREE_MODEL (priv->model), path); gtk_tree_path_free (path); g_hash_table_insert (priv->ft_handler_to_row_ref, g_object_ref (handler), row_ref); /* select the new row */ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview)); gtk_tree_selection_select_iter (selection, &iter); if (error != NULL) { message = ft_manager_format_error_message (handler, error); ft_manager_update_handler_message (manager, row_ref, message); g_free (message); return; } /* update the row with the initial values. * the only case where we postpone this is in case we're managing * an outgoing+hashing transfer, as the hashing started signal will * take care of updating the information. */ if (empathy_ft_handler_is_incoming (handler) || !empathy_ft_handler_get_use_hash (handler)) { first_line = ft_manager_format_contact_info (handler); second_line = _("Waiting for the other participant's response"); message = g_strdup_printf ("%s\n%s", first_line, second_line); ft_manager_update_handler_message (manager, row_ref, message); g_free (first_line); g_free (message); } /* hook up the signals and start the transfer */ ft_manager_start_transfer (manager, handler); }
static void connect_ip6_page (CEPageIP6 *page) { GtkWidget *content; const gchar *str_method; gboolean disabled; GtkListStore *store; GtkTreeIter iter; guint method; add_address_section (page); add_dns_section (page); add_routes_section (page); page->enabled = GTK_SWITCH (gtk_builder_get_object (CE_PAGE (page)->builder, "switch_enable")); g_signal_connect (page->enabled, "notify::active", G_CALLBACK (switch_toggled), page); str_method = nm_setting_ip6_config_get_method (page->setting); disabled = g_strcmp0 (str_method, NM_SETTING_IP6_CONFIG_METHOD_IGNORE) == 0; gtk_switch_set_active (page->enabled, !disabled); g_signal_connect_swapped (page->enabled, "notify::active", G_CALLBACK (ce_page_changed), page); content = GTK_WIDGET (gtk_builder_get_object (CE_PAGE (page)->builder, "page_content")); g_object_bind_property (page->enabled, "active", content, "sensitive", G_BINDING_SYNC_CREATE); page->method = GTK_COMBO_BOX (gtk_builder_get_object (CE_PAGE (page)->builder, "combo_addresses")); store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_UINT); gtk_list_store_insert_with_values (store, &iter, -1, METHOD_COL_NAME, _("Automatic"), METHOD_COL_METHOD, IP6_METHOD_AUTO, -1); gtk_list_store_insert_with_values (store, &iter, -1, METHOD_COL_NAME, _("Automatic, DHCP only"), METHOD_COL_METHOD, IP6_METHOD_DHCP, -1); gtk_list_store_insert_with_values (store, &iter, -1, METHOD_COL_NAME, _("Manual"), METHOD_COL_METHOD, IP6_METHOD_MANUAL, -1); gtk_list_store_insert_with_values (store, &iter, -1, METHOD_COL_NAME, _("Link-Local Only"), METHOD_COL_METHOD, IP6_METHOD_LINK_LOCAL, -1); gtk_combo_box_set_model (page->method, GTK_TREE_MODEL (store)); g_object_unref (G_OBJECT (store)); method = IP6_METHOD_AUTO; if (g_strcmp0 (str_method, NM_SETTING_IP6_CONFIG_METHOD_DHCP) == 0) { method = IP6_METHOD_DHCP; } else if (g_strcmp0 (str_method, NM_SETTING_IP6_CONFIG_METHOD_LINK_LOCAL) == 0) { method = IP6_METHOD_LINK_LOCAL; } else if (g_strcmp0 (str_method, NM_SETTING_IP6_CONFIG_METHOD_MANUAL) == 0) { method = IP6_METHOD_MANUAL; } else if (g_strcmp0 (str_method, NM_SETTING_IP6_CONFIG_METHOD_SHARED) == 0) { method = IP6_METHOD_SHARED; } else if (g_strcmp0 (str_method, NM_SETTING_IP6_CONFIG_METHOD_IGNORE) == 0) { method = IP6_METHOD_IGNORE; } page->never_default = GTK_WIDGET (gtk_builder_get_object (CE_PAGE (page)->builder, "never_default_check")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (page->never_default), nm_setting_ip6_config_get_never_default (page->setting)); g_signal_connect_swapped (page->never_default, "toggled", G_CALLBACK (ce_page_changed), page); g_signal_connect (page->method, "changed", G_CALLBACK (method_changed), page); if (method != IP6_METHOD_SHARED && method != IP6_METHOD_IGNORE) gtk_combo_box_set_active (page->method, method); }
static void gimp_gegl_tool_dialog (GimpImageMapTool *image_map_tool) { GimpGeglTool *tool = GIMP_GEGL_TOOL (image_map_tool); GimpOperationTool *o_tool = GIMP_OPERATION_TOOL (image_map_tool); GtkListStore *store; GtkCellRenderer *cell; GtkWidget *main_vbox; GtkWidget *hbox; GtkWidget *combo; GList *opclasses; GList *iter; GIMP_IMAGE_MAP_TOOL_CLASS (parent_class)->dialog (image_map_tool); main_vbox = gimp_image_map_tool_dialog_get_vbox (image_map_tool); /* The operation combo box */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0); gtk_box_reorder_child (GTK_BOX (main_vbox), hbox, 0); gtk_widget_show (hbox); store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); opclasses = gimp_get_geglopclasses (); for (iter = opclasses; iter; iter = iter->next) { GeglOperationClass *opclass = GEGL_OPERATION_CLASS (iter->data); const gchar *icon_name; const gchar *label; if (g_str_has_prefix (opclass->name, "gegl:")) { label = opclass->name + strlen ("gegl:"); icon_name = GIMP_STOCK_GEGL; } else { label = opclass->name; icon_name = NULL; } gtk_list_store_insert_with_values (store, NULL, -1, COLUMN_NAME, opclass->name, COLUMN_LABEL, label, COLUMN_ICON_NAME, icon_name, -1); } g_list_free (opclasses); combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (store)); g_object_unref (store); gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 0); gtk_widget_show (combo); cell = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), cell, FALSE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo), cell, "icon-name", COLUMN_ICON_NAME); cell = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), cell, TRUE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo), cell, "text", COLUMN_LABEL); g_signal_connect (combo, "changed", G_CALLBACK (gimp_gegl_tool_operation_changed), tool); tool->operation_combo = combo; tool->description_label = gtk_label_new (""); gtk_label_set_line_wrap (GTK_LABEL (tool->description_label), TRUE); gtk_misc_set_alignment (GTK_MISC (tool->description_label), 0.0, 0.0); gtk_box_pack_start (GTK_BOX (main_vbox), tool->description_label, FALSE, FALSE, 0); gtk_box_reorder_child (GTK_BOX (main_vbox), tool->description_label, 1); /* The options vbox */ o_tool->options_gui = gtk_label_new (_("Select an operation from the list above")); gimp_label_set_attributes (GTK_LABEL (o_tool->options_gui), PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC, -1); gtk_misc_set_padding (GTK_MISC (o_tool->options_gui), 0, 4); gtk_container_add (GTK_CONTAINER (o_tool->options_box), o_tool->options_gui); gtk_widget_show (o_tool->options_gui); }
static gboolean add_one_language (gpointer d) { AsyncLangData *data = d; char *name; char *language; GtkTreeIter iter; if (data->languages[data->position] == NULL) { /* we are done */ async_lang_data_free (data); return FALSE; } name = gdm_normalize_language_name (data->languages[data->position]); if (g_hash_table_lookup (data->user_langs, name) != NULL) { g_free (name); goto next; } if (!cc_common_language_has_font (data->languages[data->position])) { g_free (name); goto next; } if (data->regions) { language = gdm_get_region_from_name (name, NULL); } else { language = gdm_get_language_from_name (name, NULL); } if (!language) { g_debug ("Ignoring '%s' as a locale, because we couldn't figure the language name", name); g_free (name); goto next; } /* Add separator between initial languages and new additions */ if (g_object_get_data (G_OBJECT (data->store), "needs-separator")) { GtkTreeIter iter; gtk_list_store_insert_with_values (GTK_LIST_STORE (data->store), &iter, -1, LOCALE_COL, NULL, DISPLAY_LOCALE_COL, "Don't show", SEPARATOR_COL, TRUE, USER_LANGUAGE, FALSE, -1); g_object_set_data (G_OBJECT (data->store), "needs-separator", NULL); } gtk_list_store_insert_with_values (data->store, &iter, -1, LOCALE_COL, name, DISPLAY_LOCALE_COL, language, -1); g_free (name); g_free (language); next: data->position++; return TRUE; }
gboolean redownload_lrc_dia(sLrcPlugin *lrcPlug) { gint num,i; gchar *title = NULL; gchar *artist = NULL; gchar *album = NULL; GtkListStore *store; GtkTreeIter iter; GtkWidget *list; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkWidget *downwnd ; downwnd = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_widget_set_size_request(downwnd,-1,200); store = gtk_list_store_new(N_COLUMNS,G_TYPE_INT,G_TYPE_STRING,\ G_TYPE_STRING,G_TYPE_STRING); // gtk_list_store_append(store, &iter); list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); g_object_unref (G_OBJECT (store)); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Index",renderer,"text", INDEX_COLUMN,NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (list), column); column = gtk_tree_view_column_new_with_attributes ("Title",renderer,"text", TITLE_COLUMN,NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (list), column); column = gtk_tree_view_column_new_with_attributes ("Artist",renderer,"text", ARTIST_COLUMN,NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (list), column); column = gtk_tree_view_column_new_with_attributes ("Album",renderer,"text", ALBUM_COLUMN,NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (list), column); gtk_container_add (GTK_CONTAINER (downwnd), list); gtk_signal_connect(GTK_OBJECT(downwnd),"delete-event",\ GTK_SIGNAL_FUNC(downlrcdia_quit),NULL); gtk_signal_connect(GTK_OBJECT(list), "button_press_event", GTK_SIGNAL_FUNC(double_click_handler), lrcPlug); gtk_widget_show_all(downwnd); lrcPlug->get_avalible_lrc_num(lrcPlug,&num); // LDEBUG("%s %d\n",lrcPlug->currsong,num); for (i = 1;i<= num;i++) { if (lrcPlug->get_avalible_lrc_info(lrcPlug,&title,&artist,&album,i)) { // LDEBUG("%s %s %s\n",title,artist,album); gtk_list_store_insert_with_values (store, &iter,i-1, INDEX_COLUMN, i, TITLE_COLUMN, title, ARTIST_COLUMN, artist, ALBUM_COLUMN, album, -1); } } // lrcPlug->get_lrc_by_index(lrcPlug,num); return TRUE; }
void PictureEntry_Update (Picture *pic, gboolean select_it) { GdkPixbufLoader *loader = 0; GError *error = NULL; g_return_if_fail (pic != NULL || PictureEntryView != NULL); if (!pic->data) { PictureEntry_Clear(); return; } loader = gdk_pixbuf_loader_new(); if (loader) { if (gdk_pixbuf_loader_write(loader, pic->data, pic->size, &error)) { GtkTreeSelection *selection; GdkPixbuf *pixbuf; if (!gdk_pixbuf_loader_close(loader, &error)) { Log_Print(LOG_ERROR,_("Error with 'loader_close': %s"), error->message); g_error_free(error); } selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(PictureEntryView)); pixbuf = gdk_pixbuf_loader_get_pixbuf(loader); if (pixbuf) { GtkListStore *picture_store; GtkTreeIter iter1; GdkPixbuf *scaled_pixbuf; gint scaled_pixbuf_width; gint scaled_pixbuf_height; gchar *pic_info; g_object_ref(pixbuf); g_object_unref(loader); // Keep aspect ratio of the picture pic->width = gdk_pixbuf_get_width(pixbuf); pic->height = gdk_pixbuf_get_height(pixbuf); if (pic->width > pic->height) { scaled_pixbuf_width = 96; scaled_pixbuf_height = 96 * pic->height / pic->width; }else { scaled_pixbuf_width = 96 * pic->width / pic->height; scaled_pixbuf_height = 96; } scaled_pixbuf = gdk_pixbuf_scale_simple(pixbuf, scaled_pixbuf_width, scaled_pixbuf_height, //GDK_INTERP_NEAREST); // Lower quality but better speed GDK_INTERP_BILINEAR); g_object_unref(pixbuf); picture_store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(PictureEntryView))); pic_info = Picture_Info(pic); gtk_list_store_insert_with_values (picture_store, &iter1, G_MAXINT, PICTURE_COLUMN_PIC, scaled_pixbuf, PICTURE_COLUMN_TEXT, pic_info, PICTURE_COLUMN_DATA, Picture_Copy_One (pic), -1); g_free(pic_info); if (select_it) gtk_tree_selection_select_iter(selection, &iter1); g_object_unref(scaled_pixbuf); }else { GtkWidget *msgdialog; g_object_unref(loader); Log_Print (LOG_ERROR, "%s", _("Cannot display the image because not enough data has been read to determine how to create the image buffer.")); msgdialog = gtk_message_dialog_new(GTK_WINDOW(MainWindow), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "%s", _("Cannot display the image")); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (msgdialog), _("Not enough data has been read to determine how to create the image buffer.")); gtk_window_set_title (GTK_WINDOW (msgdialog), _("Load Image File")); gtk_dialog_run(GTK_DIALOG(msgdialog)); gtk_widget_destroy(msgdialog); } }else { Log_Print(LOG_ERROR,_("Error with 'loader_write': %s"), error->message); g_error_free(error); } } // Do also for next picture if (pic->next) PictureEntry_Update(pic->next, select_it); return; }
/* * Open the window to select and type the picture properties */ void Picture_Properties_Button_Clicked (GObject *object) { GtkWidget *ScrollWindowPictureTypes, *PictureTypesWindow; GtkWidget *type, *label, *desc; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeSelection *selection; GtkListStore *store; GtkTreeIter type_iter_to_select, iter; GtkTreeModel *model; GtkWindow *parent_window = NULL; GList *selection_list = NULL; GList *l; gint selection_nbr, selection_i = 1; gint response; EtPictureType pic_type; g_return_if_fail (PictureEntryView != NULL); parent_window = GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(object))); if (!gtk_widget_is_toplevel(GTK_WIDGET(parent_window))) { g_warning("Could not get parent window\n"); return; } model = gtk_tree_view_get_model(GTK_TREE_VIEW(PictureEntryView)); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(PictureEntryView)); selection_list = gtk_tree_selection_get_selected_rows(selection, NULL); selection_nbr = gtk_tree_selection_count_selected_rows(GTK_TREE_SELECTION(selection)); for (l = selection_list; l != NULL; l = g_list_next (l)) { GtkTreePath *path = l->data; Picture *pic = NULL; GtkTreeSelection *selectiontype; gchar *title; GtkTreePath *rowPath; gboolean valid; // Get corresponding picture valid = gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &iter, path); if (valid) gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, PICTURE_COLUMN_DATA, &pic, -1); title = g_strdup_printf (_("Image Properties %d/%d"), selection_i++, selection_nbr); PictureTypesWindow = gtk_dialog_new_with_buttons(title, parent_window, GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); g_free(title); gtk_dialog_set_default_response(GTK_DIALOG(PictureTypesWindow), GTK_RESPONSE_OK); ScrollWindowPictureTypes = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ScrollWindowPictureTypes), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); store = gtk_list_store_new(PICTURE_TYPE_COLUMN_COUNT, G_TYPE_STRING, G_TYPE_INT); type = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); g_object_unref (store); gtk_container_add(GTK_CONTAINER(ScrollWindowPictureTypes), type); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_title (column, _("Image Type")); gtk_tree_view_column_set_attributes(column, renderer, "text", PICTURE_TYPE_COLUMN_TEXT, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(type), column); gtk_widget_set_size_request(type, 256, 256); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(PictureTypesWindow))),ScrollWindowPictureTypes,TRUE,TRUE,0); // Behaviour following the tag type... switch (ETCore->ETFileDisplayed->ETFileDescription->TagType) { case MP4_TAG: { /* Load picture type (only Front Cover!). */ GtkTreeIter itertype; gtk_list_store_insert_with_values (store, &itertype, G_MAXINT, PICTURE_TYPE_COLUMN_TEXT, _(Picture_Type_String (ET_PICTURE_TYPE_FRONT_COVER)), PICTURE_TYPE_COLUMN_TYPE_CODE, ET_PICTURE_TYPE_FRONT_COVER, -1); /* Line to select by default. */ type_iter_to_select = itertype; break; } // Other tag types default: { // Load pictures types for (pic_type = ET_PICTURE_TYPE_OTHER; pic_type < ET_PICTURE_TYPE_UNDEFINED; pic_type++) { GtkTreeIter itertype; gtk_list_store_insert_with_values (store, &itertype, G_MAXINT, PICTURE_TYPE_COLUMN_TEXT, _(Picture_Type_String (pic_type)), PICTURE_TYPE_COLUMN_TYPE_CODE, pic_type, -1); /* Line to select by default. */ if (pic->type == pic_type) type_iter_to_select = itertype; } break; } } // Select the line by default selectiontype = gtk_tree_view_get_selection(GTK_TREE_VIEW(type)); gtk_tree_selection_select_iter(selectiontype, &type_iter_to_select); // Set visible the current selected line rowPath = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &type_iter_to_select); gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(type), rowPath, NULL, FALSE, 0, 0); gtk_tree_path_free(rowPath); // Description of the picture label = gtk_label_new (_("Image Description:")); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(PictureTypesWindow))),label,FALSE,FALSE,4); // Entry for the description desc = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(PictureTypesWindow))),desc,FALSE,FALSE,0); if (pic->description) { gchar *tmp = Try_To_Validate_Utf8_String(pic->description); gtk_entry_set_text(GTK_ENTRY(desc), tmp); g_free(tmp); } // Behaviour following the tag type... switch (ETCore->ETFileDisplayed->ETFileDescription->TagType) { case MP4_TAG: { gtk_widget_set_sensitive(GTK_WIDGET(label), FALSE); gtk_widget_set_sensitive(GTK_WIDGET(desc), FALSE); break; } // Other tag types default: { break; } } gtk_widget_show_all(PictureTypesWindow); response = gtk_dialog_run(GTK_DIALOG(PictureTypesWindow)); if (response == GTK_RESPONSE_OK) { GtkTreeModel *modeltype; GtkTreeIter itertype; modeltype = gtk_tree_view_get_model(GTK_TREE_VIEW(type)); selectiontype = gtk_tree_view_get_selection(GTK_TREE_VIEW(type)); if (gtk_tree_selection_get_selected(selectiontype, &modeltype, &itertype)) { gchar *buffer, *pic_info; gint t; gtk_tree_model_get(modeltype, &itertype, PICTURE_TYPE_COLUMN_TYPE_CODE, &t, -1); pic->type = t; buffer = g_strdup(gtk_entry_get_text(GTK_ENTRY(desc))); Strip_String(buffer); if (pic->description) g_free(pic->description); /* If the entry was empty, buffer will be the empty string "". * This can be safely passed to the underlying * FLAC__metadata_object_picture_set_description(). See * https://bugs.launchpad.net/ubuntu/+source/easytag/+bug/558804 * and https://bugzilla.redhat.com/show_bug.cgi?id=559828 for * downstream bugs when 0 was passed instead. */ pic->description = buffer; // Update value in the PictureEntryView pic_info = Picture_Info(pic); gtk_list_store_set(GTK_LIST_STORE(model), &iter, PICTURE_COLUMN_TEXT, pic_info, -1); g_free(pic_info); } } gtk_widget_destroy(PictureTypesWindow); } g_list_free_full (selection_list, (GDestroyNotify)gtk_tree_path_free); }
inline void operator()(const std::pair<std::string, std::string> &pair) { gtk_list_store_insert_with_values(store, nullptr, -1, 0, pair.first.c_str(), 1, pair.second.c_str(), -1); if(match < 0 && style_basename(pair.second) == currentstyle) match = cnt; cnt++; }
static void presence_chooser_create_model (EmpathyPresenceChooser *self) { GtkListStore *store; char *custom_message; int i; store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, /* COL_STATE_ICON_NAME */ G_TYPE_UINT, /* COL_STATE */ G_TYPE_STRING, /* COL_STATUS_TEXT */ G_TYPE_STRING, /* COL_DISPLAY_MARKUP */ G_TYPE_BOOLEAN, /* COL_STATUS_CUSTOMISABLE */ G_TYPE_INT); /* COL_TYPE */ custom_message = g_strdup_printf ("<i>%s</i>", _("Custom Message...")); for (i = 0; states[i].state != TP_CONNECTION_PRESENCE_TYPE_UNSET; i++) { GList *list, *l; const char *status, *icon_name; status = empathy_presence_get_default_message (states[i].state); icon_name = empathy_icon_name_for_presence (states[i].state); gtk_list_store_insert_with_values (store, NULL, -1, COL_STATE_ICON_NAME, icon_name, COL_STATE, states[i].state, COL_STATUS_TEXT, status, COL_DISPLAY_MARKUP, status, COL_STATUS_CUSTOMISABLE, states[i].customisable, COL_TYPE, ENTRY_TYPE_BUILTIN, -1); if (states[i].customisable) { /* Set custom messages if wanted */ list = empathy_status_presets_get (states[i].state, -1); list = g_list_sort (list, (GCompareFunc) g_utf8_collate); for (l = list; l; l = l->next) { gtk_list_store_insert_with_values (store, NULL, -1, COL_STATE_ICON_NAME, icon_name, COL_STATE, states[i].state, COL_STATUS_TEXT, l->data, COL_DISPLAY_MARKUP, l->data, COL_STATUS_CUSTOMISABLE, TRUE, COL_TYPE, ENTRY_TYPE_SAVED, -1); } g_list_free (list); gtk_list_store_insert_with_values (store, NULL, -1, COL_STATE_ICON_NAME, icon_name, COL_STATE, states[i].state, COL_STATUS_TEXT, "", COL_DISPLAY_MARKUP, custom_message, COL_STATUS_CUSTOMISABLE, TRUE, COL_TYPE, ENTRY_TYPE_CUSTOM, -1); } } /* add a separator */ gtk_list_store_insert_with_values (store, NULL, -1, COL_TYPE, ENTRY_TYPE_SEPARATOR, -1); gtk_list_store_insert_with_values (store, NULL, -1, COL_STATE_ICON_NAME, GTK_STOCK_EDIT, COL_STATUS_TEXT, "", COL_DISPLAY_MARKUP, _("Edit Custom Messages..."), COL_TYPE, ENTRY_TYPE_EDIT_CUSTOM, -1); g_free (custom_message); gtk_combo_box_set_model (GTK_COMBO_BOX (self), GTK_TREE_MODEL (store)); g_object_unref (store); }
static void picture_scaled (GObject *source_object, GAsyncResult *res, gpointer user_data) { BgPicturesSource *bg_source; CcBackgroundItem *item; GError *error = NULL; GdkPixbuf *pixbuf = NULL; const char *software; const char *uri; GtkTreeIter iter; GtkTreePath *path; GtkTreeRowReference *row_ref; GtkListStore *store; cairo_surface_t *surface = NULL; int scale_factor; item = g_object_get_data (source_object, "item"); pixbuf = gdk_pixbuf_new_from_stream_finish (res, &error); if (pixbuf == NULL) { if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { g_warning ("Failed to load image: %s", error->message); remove_placeholder (BG_PICTURES_SOURCE (user_data), item); } g_error_free (error); goto out; } /* since we were not cancelled, we can now cast user_data * back to BgPicturesSource. */ bg_source = BG_PICTURES_SOURCE (user_data); store = bg_source_get_liststore (BG_SOURCE (bg_source)); uri = cc_background_item_get_uri (item); if (uri == NULL) uri = cc_background_item_get_source_url (item); /* Ignore screenshots */ software = gdk_pixbuf_get_option (pixbuf, "tEXt::Software"); if (software != NULL && g_str_equal (software, "gnome-screenshot")) { g_debug ("Ignored URL '%s' as it's a screenshot from gnome-screenshot", uri); remove_placeholder (BG_PICTURES_SOURCE (user_data), item); goto out; } scale_factor = bg_source_get_scale_factor (BG_SOURCE (bg_source)); surface = gdk_cairo_surface_create_from_pixbuf (pixbuf, scale_factor, NULL); cc_background_item_load (item, NULL); row_ref = g_object_get_data (G_OBJECT (item), "row-ref"); if (row_ref == NULL) { /* insert the item into the liststore if it did not exist */ gtk_list_store_insert_with_values (store, NULL, -1, 0, surface, 1, item, -1); } else { path = gtk_tree_row_reference_get_path (row_ref); if (gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter, path)) { /* otherwise update the thumbnail */ gtk_list_store_set (store, &iter, 0, surface, -1); } } g_hash_table_insert (bg_source->priv->known_items, bg_pictures_source_get_unique_filename (uri), GINT_TO_POINTER (TRUE)); out: g_clear_pointer (&surface, (GDestroyNotify) cairo_surface_destroy); g_clear_object (&pixbuf); }
static void preferences_themes_setup (EmpathyPreferences *preferences) { EmpathyPreferencesPriv *priv = GET_PRIV (preferences); GtkComboBox *combo; GtkCellLayout *cell_layout; GtkCellRenderer *renderer; GtkListStore *store; const gchar **themes; GList *adium_themes; gint i; preferences_theme_variants_setup (preferences); combo = GTK_COMBO_BOX (priv->combobox_chat_theme); cell_layout = GTK_CELL_LAYOUT (combo); /* Create the model */ store = gtk_list_store_new (COL_THEME_COUNT, G_TYPE_STRING, /* Display name */ G_TYPE_STRING, /* Theme name */ G_TYPE_BOOLEAN, /* Is an Adium theme */ G_TYPE_STRING, /* Adium theme path */ G_TYPE_HASH_TABLE); /* Adium theme info */ gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store), COL_THEME_VISIBLE_NAME, GTK_SORT_ASCENDING); /* Fill the model */ themes = empathy_theme_manager_get_themes (); for (i = 0; themes[i]; i += 2) { gtk_list_store_insert_with_values (store, NULL, -1, COL_THEME_VISIBLE_NAME, _(themes[i + 1]), COL_THEME_NAME, themes[i], COL_THEME_IS_ADIUM, FALSE, -1); } adium_themes = empathy_theme_manager_get_adium_themes (); while (adium_themes != NULL) { GHashTable *info; const gchar *name; const gchar *path; info = adium_themes->data; name = tp_asv_get_string (info, "CFBundleName"); path = tp_asv_get_string (info, "path"); if (name != NULL && path != NULL) { gtk_list_store_insert_with_values (store, NULL, -1, COL_THEME_VISIBLE_NAME, name, COL_THEME_NAME, "adium", COL_THEME_IS_ADIUM, TRUE, COL_THEME_ADIUM_PATH, path, COL_THEME_ADIUM_INFO, info, -1); } g_hash_table_unref (info); adium_themes = g_list_delete_link (adium_themes, adium_themes); } /* Add cell renderer */ renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (cell_layout, renderer, TRUE); gtk_cell_layout_set_attributes (cell_layout, renderer, "text", COL_THEME_VISIBLE_NAME, NULL); gtk_combo_box_set_model (combo, GTK_TREE_MODEL (store)); g_object_unref (store); g_signal_connect (combo, "changed", G_CALLBACK (preferences_theme_changed_cb), preferences); /* Select the theme from the GSetting key and track changes */ preferences_theme_notify_cb (priv->gsettings_chat, EMPATHY_PREFS_CHAT_THEME, preferences); g_signal_connect (priv->gsettings_chat, "changed::" EMPATHY_PREFS_CHAT_THEME, G_CALLBACK (preferences_theme_notify_cb), preferences); g_signal_connect (priv->gsettings_chat, "changed::" EMPATHY_PREFS_CHAT_ADIUM_PATH, G_CALLBACK (preferences_theme_notify_cb), preferences); }
static gboolean add_single_file (BgPicturesSource *bg_source, GFile *file, const gchar *content_type, guint64 mtime, GtkTreeRowReference **ret_row_ref) { CcBackgroundItem *item = NULL; CcBackgroundItemFlags flags = 0; GtkListStore *store; GtkTreeIter iter; GtkTreePath *path = NULL; GtkTreeRowReference *row_ref = NULL; cairo_surface_t *surface = NULL; char *source_uri = NULL; char *uri = NULL; gboolean needs_download; gboolean retval = FALSE; GFile *pictures_dir, *cache_dir; GrlMedia *media; /* find png and jpeg files */ if (!content_type) goto out; if (!in_content_types (content_type)) goto out; /* create a new CcBackgroundItem */ uri = g_file_get_uri (file); pictures_dir = g_file_new_for_path (g_get_user_special_dir (G_USER_DIRECTORY_PICTURES)); cache_dir = bg_pictures_source_get_cache_file (); needs_download = !g_file_has_parent (file, pictures_dir) && !g_file_has_parent (file, cache_dir); g_object_unref (pictures_dir); g_object_unref (cache_dir); if (!needs_download) { source_uri = g_strdup (uri); flags |= CC_BACKGROUND_ITEM_HAS_URI; } else { source_uri = uri; uri = NULL; } item = cc_background_item_new (uri); flags |= CC_BACKGROUND_ITEM_HAS_SHADING | CC_BACKGROUND_ITEM_HAS_PLACEMENT; g_object_set (G_OBJECT (item), "flags", flags, "shading", G_DESKTOP_BACKGROUND_SHADING_SOLID, "placement", G_DESKTOP_BACKGROUND_STYLE_ZOOM, "modified", mtime, "needs-download", needs_download, "source-url", source_uri, NULL); if (!ret_row_ref && in_screenshot_types (content_type)) goto read_file; surface = get_content_loading_icon (BG_SOURCE (bg_source)); store = bg_source_get_liststore (BG_SOURCE (bg_source)); /* insert the item into the liststore */ gtk_list_store_insert_with_values (store, &iter, -1, 0, surface, 1, item, -1); path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), &iter); row_ref = gtk_tree_row_reference_new (GTK_TREE_MODEL (store), path); g_object_set_data_full (G_OBJECT (item), "row-ref", row_ref, (GDestroyNotify) gtk_tree_row_reference_free); read_file: media = g_object_get_data (G_OBJECT (file), "grl-media"); if (media == NULL) { g_object_set_data_full (G_OBJECT (file), "item", g_object_ref (item), g_object_unref); g_file_read_async (file, G_PRIORITY_DEFAULT, bg_source->priv->cancellable, picture_opened_for_read, bg_source); } else { GFile *native_file; GFile *thumbnail_file = NULL; gchar *native_dir; gchar *native_path; const gchar *title; const gchar *thumbnail_uri; title = grl_media_get_title (media); g_object_set (G_OBJECT (item), "name", title, NULL); thumbnail_uri = grl_media_get_thumbnail (media); thumbnail_file = g_file_new_for_uri (thumbnail_uri); native_path = gnome_desktop_thumbnail_path_for_uri (source_uri, GNOME_DESKTOP_THUMBNAIL_SIZE_LARGE); native_file = g_file_new_for_path (native_path); native_dir = g_path_get_dirname (native_path); g_mkdir_with_parents (native_dir, USER_DIR_MODE); g_object_set_data_full (G_OBJECT (thumbnail_file), "item", g_object_ref (item), g_object_unref); g_object_set_data_full (G_OBJECT (thumbnail_file), "native-file", g_object_ref (native_file), g_object_unref); g_file_copy_async (thumbnail_file, native_file, G_FILE_COPY_ALL_METADATA, G_PRIORITY_DEFAULT, bg_source->priv->cancellable, NULL, NULL, picture_copied_for_read, bg_source); g_clear_object (&thumbnail_file); g_object_unref (native_file); g_free (native_dir); g_free (native_path); } retval = TRUE; out: if (ret_row_ref) { if (row_ref && retval != FALSE) *ret_row_ref = gtk_tree_row_reference_copy (row_ref); else *ret_row_ref = NULL; } gtk_tree_path_free (path); g_clear_pointer (&surface, (GDestroyNotify) cairo_surface_destroy); g_clear_object (&item); g_object_unref (file); g_free (source_uri); g_free (uri); return retval; }
/* * Insert all desktop files in a directory into the GtkListStore. */ void apps_list_insert_files(GtkListStore *apps, GHashTable *entry_files, char *dir, DIR *dirp, size_t len) { char *fn = NULL, *name_v = NULL, *exec_v = NULL; char *icon_v = NULL; int ret; size_t len_name, len_fn; uint8_t field_code_flags; struct dirent *dp; GKeyFile *key_file = NULL; GError *error = NULL; gboolean nodisplay_v, hidden_v, use_term_v; while ((dp = readdir(dirp)) != NULL) { len_name = strlen(dp->d_name); if (len_name <= 8) goto cont; if (strncmp(dp->d_name + len_name - 8, ".desktop", 8) != 0) goto cont; len_fn = len_name + len + 1; if ((fn = calloc(len_fn, sizeof(char))) == NULL) err(1, NULL); ret = snprintf(fn, len_fn, "%s/%s", dir, dp->d_name); if (ret < 0 || (size_t)ret >= len_fn) err(1, NULL); key_file = g_key_file_new(); if (!g_key_file_load_from_file(key_file, fn, G_KEY_FILE_NONE, &error)) errx(1, "%s", error->message); nodisplay_v = g_key_file_get_boolean(key_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_NO_DISPLAY, NULL); if (nodisplay_v != FALSE) goto cont; name_v = g_key_file_get_locale_string(key_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_NAME, NULL, &error); if (name_v == NULL) { warnx("g_key_file_get_locale_string: %s", error->message); g_clear_error(&error); goto cont; } if (!g_hash_table_add(entry_files, strdup(name_v))) goto cont; hidden_v = g_key_file_get_boolean(key_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_HIDDEN, NULL); if (hidden_v != FALSE) goto cont; exec_v = g_key_file_get_locale_string(key_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_EXEC, NULL, &error); if (exec_v == NULL) { warnx("g_key_file_get_locale_string: %s", error->message); g_clear_error(&error); goto cont; } field_code_flags = field_codes(exec_v); icon_v = g_key_file_get_locale_string(key_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_ICON, NULL, &error); g_clear_error(&error); use_term_v = g_key_file_get_boolean(key_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_TERMINAL, NULL); g_clear_error(&error); gtk_list_store_insert_with_values(apps, NULL, -1, NAME_COLUMN, name_v, EXEC_COLUMN, exec_v, FCODE_COLUMN, field_code_flags, ICON_COLUMN, icon_v, TERM_COLUMN, use_term_v, -1); cont: free(exec_v); exec_v = NULL; free(name_v); name_v = NULL; free(icon_v); icon_v = NULL; free(fn); fn = NULL; if (key_file) { g_key_file_free(key_file); key_file = NULL; } } }
static void protocol_choosers_add_cm (EmpathyProtocolChooser *chooser, TpConnectionManager *cm) { EmpathyProtocolChooserPriv *priv = GET_PRIV (chooser); const TpConnectionManagerProtocol * const *iter; for (iter = cm->protocols; iter != NULL && *iter != NULL; iter++) { const TpConnectionManagerProtocol *proto = *iter; gchar *icon_name; const gchar *display_name; const gchar *saved_cm_name; saved_cm_name = g_hash_table_lookup (priv->protocols, proto->name); if (!tp_strdiff (cm->name, "haze") && saved_cm_name != NULL && tp_strdiff (saved_cm_name, "haze")) /* the CM we're adding is a haze implementation of something we already * have; drop it. */ continue; if (!tp_strdiff (cm->name, "haze") && !tp_strdiff (proto->name, "facebook")) /* Facebook now supports XMPP so drop the purple facebook plugin; user * should use Gabble */ continue; if (!tp_strdiff (cm->name, "haze") && !tp_strdiff (proto->name, "sip")) /* Haze's SIP implementation is pretty useless (bgo #629736) */ continue; if (!tp_strdiff (cm->name, "butterfly")) /* Butterfly isn't supported any more */ continue; if (tp_strdiff (cm->name, "haze") && !tp_strdiff (saved_cm_name, "haze")) { GtkTreeIter titer; gboolean valid; TpConnectionManager *haze_cm; /* let's this CM replace the haze implementation */ valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (priv->store), &titer); while (valid) { gchar *haze_proto_name = NULL; gtk_tree_model_get (GTK_TREE_MODEL (priv->store), &titer, COL_PROTOCOL_NAME, &haze_proto_name, COL_CM, &haze_cm, -1); if (haze_cm == NULL) continue; if (!tp_strdiff (haze_cm->name, "haze") && !tp_strdiff (haze_proto_name, proto->name)) { gtk_list_store_remove (priv->store, &titer); g_object_unref (haze_cm); g_free (haze_proto_name); break; } g_object_unref (haze_cm); g_free (haze_proto_name); valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (priv->store), &titer); } } g_hash_table_insert (priv->protocols, g_strdup (proto->name), g_strdup (cm->name)); icon_name = empathy_protocol_icon_name (proto->name); display_name = empathy_protocol_name_to_display_name (proto->name); gtk_list_store_insert_with_values (priv->store, NULL, 0, COL_ICON, icon_name, COL_LABEL, display_name, COL_CM, cm, COL_PROTOCOL_NAME, proto->name, -1); if (!tp_strdiff (proto->name, "jabber") && !tp_strdiff (cm->name, "gabble")) { display_name = empathy_service_name_to_display_name ("google-talk"); gtk_list_store_insert_with_values (priv->store, NULL, 0, COL_ICON, "im-google-talk", COL_LABEL, display_name, COL_CM, cm, COL_PROTOCOL_NAME, proto->name, COL_SERVICE, "google-talk", -1); display_name = empathy_service_name_to_display_name ("facebook"); gtk_list_store_insert_with_values (priv->store, NULL, 0, COL_ICON, "im-facebook", COL_LABEL, display_name, COL_CM, cm, COL_PROTOCOL_NAME, proto->name, COL_SERVICE, "facebook", -1); } g_free (icon_name); } }