static void mail_shell_view_execute_search (EShellView *shell_view) { EMailShellViewPrivate *priv; EMailShellContent *mail_shell_content; EMailShellSidebar *mail_shell_sidebar; EShellWindow *shell_window; EShellBackend *shell_backend; EShellContent *shell_content; EShellSidebar *shell_sidebar; EShellSearchbar *searchbar; EActionComboBox *combo_box; EMailBackend *backend; EMailSession *session; ESourceRegistry *registry; EMFolderTree *folder_tree; GtkWidget *message_list; EFilterRule *rule; EMailReader *reader; EMailView *mail_view; CamelVeeFolder *search_folder; CamelFolder *folder; CamelService *service; CamelStore *store; GtkAction *action; EMailLabelListStore *label_store; GtkTreePath *path; GtkTreeIter tree_iter; GString *string; GList *list, *iter; GSList *search_strings = NULL; const gchar *text; gboolean valid; gchar *query; gchar *temp; gchar *tag; const gchar *use_tag; gint value; priv = E_MAIL_SHELL_VIEW_GET_PRIVATE (shell_view); shell_window = e_shell_view_get_shell_window (shell_view); shell_backend = e_shell_view_get_shell_backend (shell_view); shell_content = e_shell_view_get_shell_content (shell_view); shell_sidebar = e_shell_view_get_shell_sidebar (shell_view); backend = E_MAIL_BACKEND (shell_backend); session = e_mail_backend_get_session (backend); mail_shell_content = E_MAIL_SHELL_CONTENT (shell_content); mail_view = e_mail_shell_content_get_mail_view (mail_shell_content); searchbar = e_mail_shell_content_get_searchbar (mail_shell_content); mail_shell_sidebar = E_MAIL_SHELL_SIDEBAR (shell_sidebar); folder_tree = e_mail_shell_sidebar_get_folder_tree (mail_shell_sidebar); reader = E_MAIL_READER (mail_view); folder = e_mail_reader_ref_folder (reader); message_list = e_mail_reader_get_message_list (reader); registry = e_mail_session_get_registry (session); label_store = e_mail_ui_session_get_label_store ( E_MAIL_UI_SESSION (session)); action = ACTION (MAIL_SEARCH_SUBJECT_OR_ADDRESSES_CONTAIN); value = gtk_radio_action_get_current_value (GTK_RADIO_ACTION (action)); text = e_shell_searchbar_get_search_text (searchbar); if (value == MAIL_SEARCH_ADVANCED || text == NULL || *text == '\0') { if (value != MAIL_SEARCH_ADVANCED) e_shell_view_set_search_rule (shell_view, NULL); query = e_shell_view_get_search_query (shell_view); if (!query) query = g_strdup (""); goto filter; } /* Replace variables in the selected rule with the * current search text and extract a query string. */ g_return_if_fail (value >= 0 && value < MAIL_NUM_SEARCH_RULES); rule = priv->search_rules[value]; /* Set the search rule in EShellView so that "Create * Search Folder from Search" works for quick searches. */ e_shell_view_set_search_rule (shell_view, rule); for (iter = rule->parts; iter != NULL; iter = iter->next) { EFilterPart *part = iter->data; EFilterElement *element = NULL; if (strcmp (part->name, "subject") == 0) element = e_filter_part_find_element (part, "subject"); else if (strcmp (part->name, "body") == 0) element = e_filter_part_find_element (part, "word"); else if (strcmp (part->name, "sender") == 0) element = e_filter_part_find_element (part, "sender"); else if (strcmp (part->name, "to") == 0) element = e_filter_part_find_element (part, "recipient"); if (strcmp (part->name, "body") == 0) { struct _camel_search_words *words; gint ii; words = camel_search_words_split ((guchar *) text); for (ii = 0; ii < words->len; ii++) search_strings = g_slist_prepend ( search_strings, g_strdup ( words->words[ii]->word)); camel_search_words_free (words); } if (element != NULL) { EFilterInput *input = E_FILTER_INPUT (element); e_filter_input_set_value (input, text); } } string = g_string_sized_new (1024); e_filter_rule_build_code (rule, string); query = g_string_free (string, FALSE); filter: /* Apply selected filter. */ combo_box = e_shell_searchbar_get_filter_combo_box (searchbar); value = e_action_combo_box_get_current_value (combo_box); switch (value) { case MAIL_FILTER_ALL_MESSAGES: break; case MAIL_FILTER_UNREAD_MESSAGES: temp = g_strdup_printf ( "(and %s (match-all (not " "(system-flag \"Seen\"))))", query); g_free (query); query = temp; break; case MAIL_FILTER_NO_LABEL: string = g_string_sized_new (1024); g_string_append_printf ( string, "(and %s (and ", query); valid = gtk_tree_model_get_iter_first ( GTK_TREE_MODEL (label_store), &tree_iter); while (valid) { tag = e_mail_label_list_store_get_tag ( label_store, &tree_iter); use_tag = tag; if (g_str_has_prefix (use_tag, "$Label")) use_tag += 6; g_string_append_printf ( string, " (match-all (not (or " "(= (user-tag \"label\") \"%s\") " "(user-flag \"$Label%s\") " "(user-flag \"%s\"))))", use_tag, use_tag, use_tag); g_free (tag); valid = gtk_tree_model_iter_next ( GTK_TREE_MODEL (label_store), &tree_iter); } g_string_append_len (string, "))", 2); g_free (query); query = g_string_free (string, FALSE); break; case MAIL_FILTER_READ_MESSAGES: temp = g_strdup_printf ( "(and %s (match-all " "(system-flag \"Seen\")))", query); g_free (query); query = temp; break; case MAIL_FILTER_LAST_5_DAYS_MESSAGES: if (em_utils_folder_is_sent (registry, folder)) temp = g_strdup_printf ( "(and %s (match-all " "(> (get-sent-date) " "(- (get-current-date) 432000))))", query); else temp = g_strdup_printf ( "(and %s (match-all " "(> (get-received-date) " "(- (get-current-date) 432000))))", query); g_free (query); query = temp; break; case MAIL_FILTER_MESSAGES_WITH_ATTACHMENTS: temp = g_strdup_printf ( "(and %s (match-all " "(system-flag \"Attachments\")))", query); g_free (query); query = temp; break; case MAIL_FILTER_IMPORTANT_MESSAGES: temp = g_strdup_printf ( "(and %s (match-all " "(system-flag \"Flagged\")))", query); g_free (query); query = temp; break; case MAIL_FILTER_MESSAGES_NOT_JUNK: temp = g_strdup_printf ( "(and %s (match-all (not " "(system-flag \"junk\"))))", query); g_free (query); query = temp; break; default: /* The action value also serves as a path for * the label list store. That's why we number * the label actions from zero. */ path = gtk_tree_path_new_from_indices (value, -1); gtk_tree_model_get_iter ( GTK_TREE_MODEL (label_store), &tree_iter, path); gtk_tree_path_free (path); tag = e_mail_label_list_store_get_tag ( label_store, &tree_iter); use_tag = tag; if (g_str_has_prefix (use_tag, "$Label")) use_tag += 6; temp = g_strdup_printf ( "(and %s (match-all (or " "(= (user-tag \"label\") \"%s\") " "(user-flag \"$Label%s\") " "(user-flag \"%s\"))))", query, use_tag, use_tag, use_tag); g_free (tag); g_free (query); query = temp; break; } /* Apply selected scope. */ combo_box = e_shell_searchbar_get_scope_combo_box (searchbar); value = e_action_combo_box_get_current_value (combo_box); switch (value) { case MAIL_SCOPE_CURRENT_FOLDER: goto execute; case MAIL_SCOPE_CURRENT_ACCOUNT: goto current_account; case MAIL_SCOPE_ALL_ACCOUNTS: goto all_accounts; default: g_warn_if_reached (); goto execute; } all_accounts: /* Prepare search folder for all accounts. */ /* If the search text is empty, cancel any * account-wide searches still in progress. */ text = e_shell_searchbar_get_search_text (searchbar); if (text == NULL || *text == '\0') { CamelStore *selected_store = NULL; gchar *selected_folder_name = NULL; if (priv->search_account_all != NULL) { g_object_unref (priv->search_account_all); priv->search_account_all = NULL; } if (priv->search_account_cancel != NULL) { g_cancellable_cancel (priv->search_account_cancel); g_object_unref (priv->search_account_cancel); priv->search_account_cancel = NULL; } /* Reset the message list to the current folder tree * selection. This needs to happen synchronously to * avoid search conflicts, so we can't just grab the * folder URI and let the asynchronous callbacks run * after we've already kicked off the search. */ em_folder_tree_get_selected ( folder_tree, &selected_store, &selected_folder_name); if (selected_store != NULL && selected_folder_name != NULL) { folder = camel_store_get_folder_sync ( selected_store, selected_folder_name, CAMEL_STORE_FOLDER_INFO_FAST, NULL, NULL); e_mail_reader_set_folder (reader, folder); g_object_unref (folder); } g_clear_object (&selected_store); g_free (selected_folder_name); gtk_widget_set_sensitive (GTK_WIDGET (combo_box), TRUE); goto execute; } search_folder = priv->search_account_all; /* Skip the search if we already have the results. */ if (search_folder != NULL) { const gchar *vf_query; vf_query = camel_vee_folder_get_expression (search_folder); if (g_strcmp0 (query, vf_query) == 0) goto all_accounts_setup; } /* Disable the scope combo while search is in progress. */ gtk_widget_set_sensitive (GTK_WIDGET (combo_box), FALSE); /* If we already have a search folder, reuse it. */ if (search_folder != NULL) { if (priv->search_account_cancel != NULL) { g_cancellable_cancel (priv->search_account_cancel); g_object_unref (priv->search_account_cancel); priv->search_account_cancel = NULL; } camel_vee_folder_set_expression (search_folder, query); goto all_accounts_setup; } /* Create a new search folder. */ /* FIXME Complete lack of error checking here. */ service = camel_session_ref_service ( CAMEL_SESSION (session), E_MAIL_SESSION_VFOLDER_UID); camel_service_connect_sync (service, NULL, NULL); search_folder = (CamelVeeFolder *) camel_vee_folder_new ( CAMEL_STORE (service), _("All Account Search"), CAMEL_STORE_FOLDER_PRIVATE); priv->search_account_all = search_folder; g_object_unref (service); camel_vee_folder_set_expression (search_folder, query); all_accounts_setup: list = em_folder_tree_model_list_stores (EM_FOLDER_TREE_MODEL ( gtk_tree_view_get_model (GTK_TREE_VIEW (folder_tree)))); g_list_foreach (list, (GFunc) g_object_ref, NULL); priv->search_account_cancel = camel_operation_new (); /* This takes ownership of the stores list. */ mail_shell_view_setup_search_results_folder ( CAMEL_FOLDER (search_folder), list, priv->search_account_cancel); mail_shell_view_show_search_results_folder ( E_MAIL_SHELL_VIEW (shell_view), CAMEL_FOLDER (search_folder)); goto execute; current_account: /* Prepare search folder for current account only. */ /* If the search text is empty, cancel any * account-wide searches still in progress. */ text = e_shell_searchbar_get_search_text (searchbar); if (text == NULL || *text == '\0') { CamelStore *selected_store = NULL; gchar *selected_folder_name = NULL; if (priv->search_account_current != NULL) { g_object_unref (priv->search_account_current); priv->search_account_current = NULL; } if (priv->search_account_cancel != NULL) { g_cancellable_cancel (priv->search_account_cancel); g_object_unref (priv->search_account_cancel); priv->search_account_cancel = NULL; } /* Reset the message list to the current folder tree * selection. This needs to happen synchronously to * avoid search conflicts, so we can't just grab the * folder URI and let the asynchronous callbacks run * after we've already kicked off the search. */ em_folder_tree_get_selected ( folder_tree, &selected_store, &selected_folder_name); if (selected_store != NULL && selected_folder_name != NULL) { folder = camel_store_get_folder_sync ( selected_store, selected_folder_name, CAMEL_STORE_FOLDER_INFO_FAST, NULL, NULL); e_mail_reader_set_folder (reader, folder); g_object_unref (folder); } g_clear_object (&selected_store); g_free (selected_folder_name); gtk_widget_set_sensitive (GTK_WIDGET (combo_box), TRUE); goto execute; } search_folder = priv->search_account_current; /* Skip the search if we already have the results. */ if (search_folder != NULL) { const gchar *vf_query; vf_query = camel_vee_folder_get_expression (search_folder); if (g_strcmp0 (query, vf_query) == 0) goto current_accout_setup; } /* Disable the scope combo while search is in progress. */ gtk_widget_set_sensitive (GTK_WIDGET (combo_box), FALSE); /* If we already have a search folder, reuse it. */ if (search_folder != NULL) { if (priv->search_account_cancel != NULL) { g_cancellable_cancel (priv->search_account_cancel); g_object_unref (priv->search_account_cancel); priv->search_account_cancel = NULL; } camel_vee_folder_set_expression (search_folder, query); goto current_accout_setup; } /* Create a new search folder. */ /* FIXME Complete lack of error checking here. */ service = camel_session_ref_service ( CAMEL_SESSION (session), E_MAIL_SESSION_VFOLDER_UID); camel_service_connect_sync (service, NULL, NULL); search_folder = (CamelVeeFolder *) camel_vee_folder_new ( CAMEL_STORE (service), _("Account Search"), CAMEL_STORE_FOLDER_PRIVATE); priv->search_account_current = search_folder; g_object_unref (service); camel_vee_folder_set_expression (search_folder, query); current_accout_setup: if (folder != NULL && folder != CAMEL_FOLDER (search_folder)) { store = camel_folder_get_parent_store (folder); if (store != NULL) g_object_ref (store); } else { store = NULL; em_folder_tree_get_selected (folder_tree, &store, NULL); } list = NULL; /* list of CamelStore-s */ if (store != NULL) list = g_list_append (NULL, store); priv->search_account_cancel = camel_operation_new (); /* This takes ownership of the stores list. */ mail_shell_view_setup_search_results_folder ( CAMEL_FOLDER (search_folder), list, priv->search_account_cancel); mail_shell_view_show_search_results_folder ( E_MAIL_SHELL_VIEW (shell_view), CAMEL_FOLDER (search_folder)); execute: /* Finally, execute the search. */ message_list_set_search (MESSAGE_LIST (message_list), query); e_mail_view_set_search_strings (mail_view, search_strings); g_slist_foreach (search_strings, (GFunc) g_free, NULL); g_slist_free (search_strings); g_free (query); g_clear_object (&folder); }
static void bar_pane_keywords_menu_popup(GtkWidget *widget, PaneKeywordsData *pkd, gint x, gint y) { GtkWidget *menu; GtkWidget *item; GtkWidget *submenu; GtkTreeViewDropPosition pos; if (pkd->click_tpath) gtk_tree_path_free(pkd->click_tpath); pkd->click_tpath = NULL; gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(pkd->keyword_treeview), x, y, &pkd->click_tpath, &pos); menu = popup_menu_short_lived(); menu_item_add_stock(menu, _("Add keyword"), GTK_STOCK_EDIT, G_CALLBACK(bar_pane_keywords_add_dialog_cb), pkd); menu_item_add_divider(menu); menu_item_add(menu, _("Add keyword to all selected images"), G_CALLBACK(bar_pane_keywords_add_to_selected_cb), pkd); menu_item_add_divider(menu); if (pkd->click_tpath) { /* for the entry */ gchar *text; gchar *mark; gint i; GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview)); GtkTreeIter iter; gtk_tree_model_get_iter(model, &iter, pkd->click_tpath); gchar *name; gtk_tree_model_get(model, &iter, FILTER_KEYWORD_COLUMN_NAME, &name, FILTER_KEYWORD_COLUMN_MARK, &mark, -1); text = g_strdup_printf(_("Hide \"%s\""), name); menu_item_add_stock(menu, text, GTK_STOCK_EDIT, G_CALLBACK(bar_pane_keywords_hide_cb), pkd); g_free(text); submenu = gtk_menu_new(); for (i = 0; i < FILEDATA_MARKS_SIZE; i++) { text = g_strdup_printf(_("Mark %d"), i + 1); item = menu_item_add(submenu, text, G_CALLBACK(bar_pane_keywords_connect_mark_cb), pkd); g_object_set_data(G_OBJECT(item), "mark", GINT_TO_POINTER(i + 1)); g_free(text); } text = g_strdup_printf(_("Connect \"%s\" to mark"), name); item = menu_item_add(menu, text, NULL, NULL); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu); g_free(text); menu_item_add_divider(menu); text = g_strdup_printf(_("Edit \"%s\""), name); menu_item_add_stock(menu, text, GTK_STOCK_EDIT, G_CALLBACK(bar_pane_keywords_edit_dialog_cb), pkd); g_free(text); text = g_strdup_printf(_("Remove \"%s\""), name); menu_item_add_stock(menu, text, GTK_STOCK_DELETE, G_CALLBACK(bar_pane_keywords_delete_cb), pkd); g_free(text); if (mark && mark[0]) { text = g_strdup_printf(_("Disconnect \"%s\" from mark %s"), name, mark); menu_item_add_stock(menu, text, GTK_STOCK_DELETE, G_CALLBACK(bar_pane_keywords_connect_mark_cb), pkd); g_free(text); } menu_item_add_divider(menu); g_free(mark); g_free(name); } /* for the pane */ menu_item_add(menu, _("Expand checked"), G_CALLBACK(bar_pane_keywords_expand_checked_cb), pkd); menu_item_add(menu, _("Collapse unchecked"), G_CALLBACK(bar_pane_keywords_collapse_unchecked_cb), pkd); menu_item_add(menu, _("Hide unchecked"), G_CALLBACK(bar_pane_keywords_hide_unchecked_cb), pkd); menu_item_add(menu, _("Show all"), G_CALLBACK(bar_pane_keywords_show_all_cb), pkd); submenu = gtk_menu_new(); item = menu_item_add(menu, _("On any change"), NULL, NULL); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu); menu_item_add_check(submenu, _("Expand checked"), pkd->expand_checked, G_CALLBACK(bar_pane_keywords_expand_checked_toggle_cb), pkd); menu_item_add_check(submenu, _("Collapse unchecked"), pkd->collapse_unchecked, G_CALLBACK(bar_pane_keywords_collapse_unchecked_toggle_cb), pkd); menu_item_add_check(submenu, _("Hide unchecked"), pkd->hide_unchecked, G_CALLBACK(bar_pane_keywords_hide_unchecked_toggle_cb), pkd); gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 0, GDK_CURRENT_TIME); }
static void bar_pane_keywords_edit_ok_cb(GenericDialog *gd, gpointer data) { ConfDialogData *cdd = data; PaneKeywordsData *pkd = cdd->pkd; GtkTreeModel *model; GtkTreeModel *keyword_tree; GtkTreeIter kw_iter; gboolean have_dest = FALSE; GList *keywords; model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview)); keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model)); if (cdd->click_tpath) { GtkTreeIter iter; if (gtk_tree_model_get_iter(model, &iter, cdd->click_tpath)) { gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &kw_iter, &iter); have_dest = TRUE; } } if (cdd->edit_existing && !have_dest) return; keywords = keyword_list_pull(cdd->edit_widget); if (cdd->edit_existing) { if (keywords && keywords->data && /* there should be one keyword */ !keyword_exists(keyword_tree, NULL, &kw_iter, keywords->data, TRUE, NULL)) { keyword_set(GTK_TREE_STORE(keyword_tree), &kw_iter, keywords->data, cdd->is_keyword); } } else { GList *work = keywords; gboolean append_to = FALSE; while (work) { GtkTreeIter add; if (keyword_exists(keyword_tree, NULL, (have_dest || append_to) ? &kw_iter : NULL, work->data, FALSE, NULL)) { work = work->next; continue; } if (have_dest) { gtk_tree_store_append(GTK_TREE_STORE(keyword_tree), &add, &kw_iter); } else if (append_to) { gtk_tree_store_insert_after(GTK_TREE_STORE(keyword_tree), &add, NULL, &kw_iter); } else { gtk_tree_store_append(GTK_TREE_STORE(keyword_tree), &add, NULL); append_to = TRUE; kw_iter = add; } keyword_set(GTK_TREE_STORE(keyword_tree), &add, work->data, cdd->is_keyword); work = work->next; } } string_list_free(keywords); }
void TreeViewCategories_Paste(TreeViewCategories* c, unsigned int IsRoot) { GtkTreeModel* tree_model; GtkTreePath* TreePathMoveDst; gint* indices_src; gint depth_src; gint* indices_dst; gint depth_dst; gchar* NameSrc; gchar* NameDst; int i; GtkTreeIter iter_dst; GtkTreeIter* iter_dst_ptr; GtkTreeIter iter_src; if (c->TreePathMoveSrc == NULL) { return ; } tree_model = gtk_tree_view_get_model(GTK_TREE_VIEW(c->treeview)); gtk_tree_model_get_iter(tree_model, &iter_src, c->TreePathMoveSrc); NameSrc = gtk_tree_path_indices_name_gen(c->TreePathMoveSrc, "cat-src://", "/"); if (IsRoot) { TreePathMoveDst = NULL; iter_dst_ptr = NULL; NameDst = gtk_tree_path_indices_name_gen(TreePathMoveDst, "cat-dst://", "/"); g_print("%s\n" "%s.", NameSrc, NameDst); indices_src = gtk_tree_path_get_indices_with_depth(c->TreePathMoveSrc, &depth_src); if (depth_src == 1) { g_print(" Исходное и конечное совпадают.\n\n"); goto PASTE_FAIL; } g_print("\n\n"); } else { gtk_tree_view_get_cursor(GTK_TREE_VIEW(c->treeview), &TreePathMoveDst, NULL); if (TreePathMoveDst == NULL) { goto PASTE_FAIL; } gtk_tree_model_get_iter(tree_model, &iter_dst, TreePathMoveDst); iter_dst_ptr = &iter_dst; NameDst = gtk_tree_path_indices_name_gen(TreePathMoveDst, "cat-dst://", "/"); g_print("%s\n" "%s.", NameSrc, NameDst); indices_src = gtk_tree_path_get_indices_with_depth(c->TreePathMoveSrc, &depth_src); indices_dst = gtk_tree_path_get_indices_with_depth(TreePathMoveDst, &depth_dst); for (i = 0; i < depth_src && i < depth_dst; ++i) { if (indices_src[i] != indices_dst[i]) break; } if (i == depth_src) { g_print(" В себя же нельзя.\n\n"); goto PASTE_FAIL; } if (i + 1 == depth_src && i == depth_dst) { g_print(" Исходное и конечное совпадают.\n\n"); goto PASTE_FAIL; } g_print("\n\n"); } gtk_tree_store_move(GTK_TREE_STORE(tree_model), &iter_src, iter_dst_ptr); c->cat_update.new_cat_id = c->new_cat_id; c->cat_update.MySQL = c->MySQL; TreeViewCategories_Enumerate(c, GTK_TREE_STORE(tree_model), NULL, 0); CatUpdate_Execute(&c->cat_update); CatUpdate_Free(&c->cat_update); gtk_tree_path_free(c->TreePathMoveSrc); c->TreePathMoveSrc = NULL; PASTE_FAIL: if (TreePathMoveDst != NULL) gtk_tree_path_free(TreePathMoveDst); if (NameSrc != NULL) g_free(NameSrc); if (NameDst != NULL) g_free(NameDst); }
static void toggled_callback (GtkCellRendererToggle *celltoggle, gchar *path_string, GtkTreeView *tree_view) { GtkTreeModel *model = NULL; GtkTreeModelSort *sort_model = NULL; GtkTreePath *path; GtkTreeIter iter; gboolean active = FALSE; g_return_if_fail (GTK_IS_TREE_VIEW (tree_view)); model = gtk_tree_view_get_model (tree_view); if (GTK_IS_TREE_MODEL_SORT (model)) { sort_model = GTK_TREE_MODEL_SORT (model); model = gtk_tree_model_sort_get_model (sort_model); } if (model == NULL) return; if (sort_model) { g_warning ("FIXME implement conversion from TreeModelSort iter to child model iter"); return; } path = gtk_tree_path_new_from_string (path_string); if (!gtk_tree_model_get_iter (model, &iter, path)) { g_warning ("%s: bad path?", G_STRLOC); return; } gtk_tree_path_free (path); if (GTK_IS_LIST_STORE (model)) { gtk_tree_model_get (GTK_TREE_MODEL (model), &iter, BOOL_COLUMN, &active, -1); gtk_list_store_set (GTK_LIST_STORE (model), &iter, BOOL_COLUMN, !active, -1); } else if (GTK_IS_TREE_STORE (model)) { gtk_tree_model_get (GTK_TREE_MODEL (model), &iter, BOOL_COLUMN, &active, -1); gtk_tree_store_set (GTK_TREE_STORE (model), &iter, BOOL_COLUMN, !active, -1); } else g_warning ("don't know how to actually toggle value for model type %s", g_type_name (G_TYPE_FROM_INSTANCE (model))); }
static gint on_button_press_event (GtkWidget *widget, GdkEventButton *event, GtkamList *list) { GtkTreePath *path = NULL; GtkWidget *w; GtkamCamera *camera; CameraAbilities a; switch (event->button) { case 3: if (!gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (list), event->x, event->y, &path, NULL, NULL, NULL)) return (FALSE); gtk_tree_model_get_iter (GTK_TREE_MODEL (list->priv->store), &list->priv->iter, path); gtk_tree_path_free (path); camera = gtkam_list_get_camera_from_iter (list, &list->priv->iter); gp_camera_get_abilities (camera->camera, &a); /* What operations does the camera support? */ w = gtk_item_factory_get_widget (list->priv->factory, "/Delete"); gtk_widget_set_sensitive (w, (a.file_operations & GP_FILE_OPERATION_DELETE)); #ifdef HAVE_BONOBO { Bonobo_ServerInfoList *l; guint i; GtkWidget *item, *c; CORBA_Environment ev; CameraFileInfo finfo; gchar *fo, *fi, *query; ViewAsData *d; GList *cl; w = gtk_item_factory_get_widget (list->priv->factory, "/View with..."); c = gtk_item_factory_get_widget (list->priv->factory, "/View with.../Built-in viewer"); cl = gtk_container_get_children (GTK_CONTAINER (w)); for (i = 0; i < g_list_length (cl); i++) { if (g_list_nth_data (cl, i) != c) gtk_container_remove (GTK_CONTAINER (w), GTK_WIDGET (g_list_nth_data (cl, i))); } fo = gtkam_list_get_folder_from_iter (list, &list->priv->iter); fi = gtkam_list_get_name_from_iter (list, &list->priv->iter); gp_camera_file_get_info (camera->camera, fo, fi, &finfo, NULL); g_free (fo); g_free (fi); if (finfo.file.fields & GP_FILE_INFO_TYPE) { CORBA_exception_init (&ev); query = g_strconcat ("repo_ids.has ('IDL:Bonobo/Control:1.0') AND " "bonobo:supported_mime_types.has ('", finfo.file.type, "')", NULL); l = bonobo_activation_query (query, NULL, &ev); g_free (query); CORBA_exception_free (&ev); if (l && l->_length) { for (i = 0; i < l->_length; i++) { Bonobo_ServerInfo *si = &l->_buffer[i]; const gchar *n; if (!si->iid) continue; n = bonobo_server_info_prop_lookup (si, "name", NULL); if (!n) n = si->iid; item = gtk_menu_item_new_with_label (n); gtk_widget_show (item); gtk_menu_shell_append (GTK_MENU_SHELL (w), item); d = g_new0 (ViewAsData, 1); d->list = list; d->camera = camera; g_object_ref (G_OBJECT (d->camera)); d->folder = gtkam_list_get_folder_from_iter (list, &list->priv->iter); d->file = gtkam_list_get_name_from_iter (list, &list->priv->iter); d->iid = g_strdup (si->iid); g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (on_view_as_activate), d); g_signal_connect (G_OBJECT (item), "destroy", G_CALLBACK (on_menu_item_destroy), d); } } if (l) CORBA_free (l); } } #endif gtk_item_factory_popup (list->priv->factory, event->x_root, event->y_root, event->button, event->time); return (TRUE); default: return (FALSE); } }
static void rc_gui_list1_dnd_data_received(GtkWidget *widget, GdkDragContext *context, gint x, gint y, GtkSelectionData *seldata, guint info, guint time, gpointer data) { gint source = -1; gint target = 0; gint *index = NULL; gint i = 0; gint length = 0; gboolean end_flag = FALSE; GtkTreeViewDropPosition pos; GtkTreePath *path_start = NULL, *path_drop = NULL; GtkTreeIter iter_start, iter_drop; GList *path_list = NULL; GList *list_foreach = NULL; GtkTreePath **path_array; gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW( rc_ui->list1_tree_view), x,y, &path_drop, &pos); if(path_drop!=NULL) { gtk_tree_model_get_iter(rc_ui->list1_tree_model, &iter_drop, path_drop); index = gtk_tree_path_get_indices(path_drop); target = index[0]; gtk_tree_path_free(path_drop); } else end_flag = TRUE; switch(info) { case 0: { source = *(gtk_selection_data_get_data(seldata)); if(pos==GTK_TREE_VIEW_DROP_AFTER || pos==GTK_TREE_VIEW_DROP_INTO_OR_AFTER) { target++; if(!gtk_tree_model_iter_next(rc_ui->list1_tree_model, &iter_drop)) end_flag = TRUE; } path_start = gtk_tree_path_new_from_indices(source, -1); gtk_tree_model_get_iter(rc_ui->list1_tree_model, &iter_start, path_start); gtk_tree_path_free(path_start); if(!end_flag) gtk_list_store_move_before(GTK_LIST_STORE( rc_ui->list1_tree_model), &iter_start, &iter_drop); else gtk_list_store_move_before(GTK_LIST_STORE( rc_ui->list1_tree_model), &iter_start, NULL); break; } case 1: { if(target==rc_gui_list1_get_selected_index()) break; memcpy(&path_list, gtk_selection_data_get_data(seldata), sizeof(path_list)); if(path_list==NULL) break; length = g_list_length(path_list); path_list = g_list_sort_with_data(path_list, (GCompareDataFunc) gtk_tree_path_compare, NULL); path_array = g_new0(GtkTreePath *, length); for(list_foreach=path_list, i=0;list_foreach!=NULL; list_foreach=g_list_next(list_foreach), i++) { path_array[i] = list_foreach->data; } rc_plist_plist_move2(rc_gui_list1_get_selected_index(), path_array, length, target); break; } default: break; } }
static void accel_edited_callback (GtkCellRendererAccel *cell, gchar *path_string, guint keyval, GdkModifierType mask, guint hardware_keycode, GtkTreeView *view) { GtkTreeModel *model; GtkTreePath *path; GtkTreeIter iter; KeyEntry *ke; GtkAccelGroupEntry *entries; guint n_entries; char *str; model = gtk_tree_view_get_model (view); path = gtk_tree_path_new_from_string (path_string); if (!path) return; if (!gtk_tree_model_get_iter (model, &iter, path)) { gtk_tree_path_free (path); return; } gtk_tree_path_free (path); gtk_tree_model_get (model, &iter, KEYVAL_COLUMN, &ke, -1); /* sanity check */ if (ke == NULL) return; /* Check if we already have an entry using this accel */ entries = gtk_accel_group_query (notification_group, keyval, mask, &n_entries); if (n_entries > 0) { if (entries[0].accel_path_quark != g_quark_from_string (ke->accel_path)) { GtkWidget *dialog; char *name; KeyEntry *other_key; name = gtk_accelerator_get_label (keyval, mask); other_key = entries[0].closure->data; g_assert (other_key); dialog = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (view))), GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("The shortcut key “%s” is already bound to the “%s” action"), name, other_key->user_visible_name ? _(other_key->user_visible_name) : other_key->gsettings_key); g_free (name); g_signal_connect (dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL); gtk_window_present (GTK_WINDOW (dialog)); } return; } str = binding_name (keyval, mask); _terminal_debug_print (TERMINAL_DEBUG_ACCELS, "Edited path %s keyval %s, setting GSettings to %s\n", ke->accel_path, gdk_keyval_name (keyval) ? gdk_keyval_name (keyval) : "null", str); #ifdef MATE_ENABLE_DEBUG _TERMINAL_DEBUG_IF (TERMINAL_DEBUG_ACCELS) { GtkAccelKey old_key; if (gtk_accel_map_lookup_entry (ke->accel_path, &old_key)) { _terminal_debug_print (TERMINAL_DEBUG_ACCELS, " Old entry of path %s is keyval %s mask %x\n", ke->accel_path, gdk_keyval_name (old_key.accel_key), old_key.accel_mods); } else { _terminal_debug_print (TERMINAL_DEBUG_ACCELS, " Failed to look up the old entry of path %s\n", ke->accel_path); } } #endif g_settings_set_string (settings_keybindings, ke->gsettings_key, str); g_free (str); }
void on_colordiag_ok_clicked (GtkButton * button, gpointer user_data) { GtkWidget *colorsel, *colorseldiag; GdkColor gdk_color; GtkTreePath *gpath = NULL; GtkTreeViewColumn *gcol = NULL; GtkTreeIter it; gint isadd; EATreePos ep; if (!get_color_store (&ep)) return; colorseldiag = glade_xml_get_widget (appdata.xml, "colorselectiondialog"); isadd = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(colorseldiag), "isadd")); /* gets the row (path) at cursor */ gtk_tree_view_get_cursor (ep.gv, &gpath, &gcol); if (isadd) { if (gpath) { /* row sel, add/change color */ GtkTreeIter itsibling; if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (ep.gs), &itsibling, gpath)) return; /* path not found */ gtk_list_store_insert_before (ep.gs, &it, &itsibling); } else gtk_list_store_append (ep.gs, &it); /* no row selected, append */ } else { if (!gpath || !gtk_tree_model_get_iter(GTK_TREE_MODEL (ep.gs), &it, gpath)) return; /* path not found */ } /* get the selected color */ colorsel = GTK_COLOR_SELECTION_DIALOG (colorseldiag)->colorsel; gtk_color_selection_get_current_color (GTK_COLOR_SELECTION (colorsel), &gdk_color); /* Since we are only going to save 24bit precision, we might as well * make sure we don't display any more than that */ gdk_color.red = (gdk_color.red >> 8) << 8; gdk_color.green = (gdk_color.green >> 8) << 8; gdk_color.blue = (gdk_color.blue >> 8) << 8; /* fill data */ if (isadd) gtk_list_store_set (ep.gs, &it, 0, COLSPACES, 1, &gdk_color, 2, "", -1); else gtk_list_store_set (ep.gs, &it, 0, COLSPACES, 1, &gdk_color, -1); gtk_widget_hide (colorseldiag); color_list_to_pref (); colors_changed = TRUE; } /* on_colordiag_ok_clicked */
void cb_apply_auth(GtkButton *button, gpointer data) { GtkTreeModel *model = GTK_TREE_MODEL(data); GtkTreePath *path; GtkTreeIter iter; GSList *iterator; gchar *uid; gint auth ; gchar *u, *m, *o, *a, *t; for (iterator = upt_list; iterator; iterator = iterator->next) { path = gtk_tree_row_reference_get_path(iterator->data); gtk_tree_model_get_iter(model, &iter, path); gtk_tree_model_get(model, &iter, COLUMN_AUTH_UID, &uid, -1); gtk_tree_model_get(model, &iter, COLUMN_AUTH_U, &u, -1); gtk_tree_model_get(model, &iter, COLUMN_AUTH_M, &m, -1); gtk_tree_model_get(model, &iter, COLUMN_AUTH_O, &o, -1); gtk_tree_model_get(model, &iter, COLUMN_AUTH_A, &a, -1); gtk_tree_model_get(model, &iter, COLUMN_AUTH_T, &t, -1); auth = 0; if (g_strcmp0(u, authinfo[0]) == 0) { auth |= U_S_AUTH; } if (g_strcmp0(u, authinfo[1]) == 0) { auth |= U_U_AUTH; } if (g_strcmp0(u, authinfo[2]) == 0) { auth |= U_N_AUTH; } if (g_strcmp0(m, authinfo[0]) == 0) { auth |= M_S_AUTH; } if (g_strcmp0(m, authinfo[1]) == 0) { auth |= M_U_AUTH; } if (g_strcmp0(m, authinfo[2]) == 0) { auth |= M_N_AUTH; } if (g_strcmp0(o, authinfo[0]) == 0) { auth |= O_S_AUTH; } if (g_strcmp0(o, authinfo[1]) == 0) { auth |= O_U_AUTH; } if (g_strcmp0(o, authinfo[2]) == 0) { auth |= O_N_AUTH; } if (g_strcmp0(a, authinfo[0]) == 0) { auth |= A_S_AUTH; } if (g_strcmp0(a, authinfo[1]) == 0) { auth |= A_U_AUTH; } if (g_strcmp0(a, authinfo[2]) == 0) { auth |= A_N_AUTH; } if (g_strcmp0(t, authinfo[0]) == 0) { auth |= T_S_AUTH; } if (g_strcmp0(t, authinfo[1]) == 0) { auth |= T_U_AUTH; } if (g_strcmp0(t, authinfo[2]) == 0) { auth |= T_N_AUTH; } update_auth(uid, auth); g_free(uid); g_free(u); g_free(m); g_free(o); g_free(a); g_free(t); } upt_list = NULL; }
void edit_tags_current_playlist(GtkAction *action, struct con_win *cwin) { struct tags otag, ntag; struct musicobject *mobj = NULL; GtkTreeModel *model; GtkTreeSelection *selection; GtkTreeRowReference *ref; GtkTreePath *path = NULL; GtkTreeIter iter; GList *list, *i; GArray *loc_arr = NULL, *file_arr = NULL; gint sel = 0, location_id, changed = 0, j = 0; gchar *sfile = NULL, *tfile; memset(&otag, 0, sizeof(struct tags)); memset(&ntag, 0, sizeof(struct tags)); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(cwin->current_playlist)); sel = gtk_tree_selection_count_selected_rows(selection); if (!sel) return; list = gtk_tree_selection_get_selected_rows(selection, &model); /* Setup initial entries */ if (sel == 1) { path = list->data; if (!gtk_tree_model_get_iter(model, &iter, path)) goto exit; gtk_tree_model_get(model, &iter, P_MOBJ_PTR, &mobj, -1); if (!mobj) { g_warning("Invalid mobj pointer"); goto exit; } memcpy(&otag, mobj->tags, sizeof(struct tags)); } /* Get references from the paths and store them in the 'data' portion of the list elements. This idea was inspired by code from 'claws-mail' */ for (i = list; i != NULL; i = i->next) { path = i->data; ref = gtk_tree_row_reference_new(model, path); i->data = ref; gtk_tree_path_free(path); } /* Get new tags edited */ changed = tag_edit_dialog(&otag, &ntag, (mobj != NULL) ? mobj->file : NULL, cwin); if (!changed) goto exit; loc_arr = g_array_new(TRUE, TRUE, sizeof(gint)); file_arr = g_array_new(TRUE, TRUE, sizeof(gchar *)); clear_sort_current_playlist_cb(NULL, cwin); /* Now build iterators from the references and edit them from the store */ for (i = list; i != NULL; i = i->next) { mobj = NULL; ref = i->data; path = gtk_tree_row_reference_get_path(ref); gtk_tree_row_reference_free(ref); if (G_LIKELY(gtk_tree_model_get_iter(model, &iter, path))) gtk_tree_path_free(path); else continue; gtk_tree_model_get(model, &iter, P_MOBJ_PTR, &mobj, -1); if (G_UNLIKELY(mobj == NULL)) { g_warning("Invalid mobj pointer"); continue; } if (G_UNLIKELY(mobj == cwin->cstate->curr_mobj)) { update_musicobject(cwin->cstate->curr_mobj, changed, &ntag, cwin); if(cwin->cstate->state != ST_STOPPED) { __update_current_song_info(cwin); mpris_update_metadata_changed(cwin); } } else { update_musicobject(mobj, changed, &ntag, cwin); } update_track_current_playlist(&iter, changed, mobj, cwin); if(G_LIKELY(mobj->file_type != FILE_CDDA)) { sfile = sanitize_string_sqlite3(mobj->file); location_id = find_location_db(sfile, cwin); if (G_LIKELY(location_id)) { g_array_append_val(loc_arr, location_id); g_free(sfile); continue; } tfile = g_strdup(mobj->file); file_arr = g_array_append_val(file_arr, tfile); g_free(sfile); } } tag_update(loc_arr, file_arr, changed, &ntag, cwin); if (changed && (loc_arr || file_arr)) init_library_view(cwin); exit: /* Cleanup */ if (loc_arr) g_array_free(loc_arr, TRUE); if (file_arr) { gchar *elem = NULL; for (j = 0; j < file_arr->len; j++) { elem = g_array_index(file_arr, gchar *, j); g_free(elem); } g_array_free(file_arr, TRUE); } g_free(ntag.title); g_free(ntag.artist); g_free(ntag.album); g_free(ntag.genre); g_free(ntag.comment); g_list_free(list); }
/* List Selection Callback */ static gboolean selection_made_callback(GtkTreeSelection *selection, gpointer data) { gchar *entry_name; gchar *entry_pass; gchar *entry_service; gboolean autoconnect; int x, y; GtkTreeViewColumn *column = NULL; GtkTreeIter sel; GList *path_list; gint sel_count = gtk_tree_selection_count_selected_rows(selection); if (sel_count < 1 || sel_count > 1) { gtk_entry_set_text(GTK_ENTRY(username), ""); gtk_entry_set_text(GTK_ENTRY(password), ""); if (sel_count > 1) { gtk_widget_set_sensitive(GTK_WIDGET(mod_button), FALSE); gtk_widget_set_sensitive(GTK_WIDGET(del_button), TRUE); gtk_combo_box_set_active(GTK_COMBO_BOX(service_type), -1); } else { gtk_widget_set_sensitive(GTK_WIDGET(mod_button), FALSE); gtk_widget_set_sensitive(GTK_WIDGET(del_button), FALSE); gtk_combo_box_set_active(GTK_COMBO_BOX(service_type), -1); } return FALSE; } path_list = gtk_tree_selection_get_selected_rows(selection, NULL); gtk_tree_model_get_iter(GTK_TREE_MODEL(account_list_store), &sel, path_list->data); g_list_foreach(path_list, (GFunc) gtk_tree_path_free, NULL); g_list_free(path_list); selected_row = sel; gtk_widget_get_pointer(account_list, &x, &y); gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(account_list), x, y, NULL, &column, NULL, NULL); if (column && !strcmp(gtk_tree_view_column_get_title(column), _("C"))) { gboolean autoconnect; gtk_tree_model_get(GTK_TREE_MODEL(account_list_store), &selected_row, CONNECT, &autoconnect, -1); gtk_list_store_set(account_list_store, &selected_row, CONNECT, !autoconnect, -1); } gtk_tree_model_get(GTK_TREE_MODEL(account_list_store), &sel, CONNECT, &autoconnect, USER_NAME, &entry_name, PASSWORD, &entry_pass, SERVICE_TYPE, &entry_service, -1); gtk_entry_set_text(GTK_ENTRY(username), entry_name); gtk_entry_set_text(GTK_ENTRY(password), entry_pass); { int i; LList *l, *list = get_service_list(); for (l = list, i = 0; l; l = l_list_next(l), i++) { char *name = l->data; if (!strcmp(name, entry_service)) { gtk_combo_box_set_active(GTK_COMBO_BOX (service_type), i); break; } } l_list_free(list); } gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(connect_at_startup), autoconnect); gtk_widget_set_sensitive(GTK_WIDGET(mod_button), TRUE); gtk_widget_set_sensitive(GTK_WIDGET(del_button), TRUE); return FALSE; }
void bmd_cell_edited (GtkCellRendererText *cell, const gchar *path_string, const gchar *new_text, gpointer data) { GtkTreeModel *model = (GtkTreeModel *) data; GtkTreePath *path = gtk_tree_path_new_from_string (path_string); GtkTreeIter iter; gint column = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (cell), "column")); gtk_tree_model_get_iter (model, &iter, path); switch (column) { case COLUMN_ITEM_NUMBER: { gint i; i = gtk_tree_path_get_indices (path) [0]; g_array_index (articles, Item, i).number = atoi (new_text); gtk_list_store_set (GTK_LIST_STORE (model), &iter, column, g_array_index (articles, Item, i).number, -1); } break; case COLUMN_ITEM_TITLE: { gint i; gchar *old_text; gtk_tree_model_get (model, &iter, column, &old_text, -1); g_free (old_text); i = gtk_tree_path_get_indices (path) [0]; g_free (g_array_index (articles, Item, i).title); g_array_index (articles, Item, i).title = g_strdup (new_text); gtk_list_store_set (GTK_LIST_STORE (model), &iter, column, g_array_index (articles, Item, i).title, -1); } break; case COLUMN_ITEM_AUTHOR: { gint i; gchar *old_text; gtk_tree_model_get (model, &iter, column, &old_text, -1); g_free (old_text); i = gtk_tree_path_get_indices (path) [0]; g_free (g_array_index (articles, Item, i).author); g_array_index (articles, Item, i).author = g_strdup (new_text); gtk_list_store_set (GTK_LIST_STORE (model), &iter, column, g_array_index (articles, Item, i).author, -1); } break; case COLUMN_ITEM_PAGES: { gint i; i = gtk_tree_path_get_indices (path) [0]; g_array_index (articles, Item, i).pages = atoi (new_text); gtk_list_store_set (GTK_LIST_STORE (model), &iter, column, g_array_index (articles, Item, i).pages, -1); } break; } gtk_tree_path_free (path); }
static void mail_shell_view_update_actions (EShellView *shell_view) { EMailShellView *mail_shell_view; EMailShellContent *mail_shell_content; EMailShellSidebar *mail_shell_sidebar; EShellSidebar *shell_sidebar; EShellWindow *shell_window; EMFolderTree *folder_tree; EMFolderTreeModel *model; EMailReader *reader; EMailView *mail_view; GtkAction *action; CamelStore *store = NULL; GList *list, *link; gchar *folder_name = NULL; gboolean sensitive; guint32 state; /* Be descriptive. */ gboolean folder_allows_children; gboolean folder_can_be_deleted; gboolean folder_is_outbox; gboolean folder_is_selected = FALSE; gboolean folder_is_store; gboolean folder_is_trash; gboolean folder_is_virtual; gboolean folder_has_unread = FALSE; gboolean folder_has_unread_rec = FALSE; gboolean folder_tree_and_message_list_agree = TRUE; gboolean store_is_builtin; gboolean store_is_subscribable; gboolean store_can_be_disabled; gboolean any_store_is_subscribable = FALSE; /* Chain up to parent's update_actions() method. */ E_SHELL_VIEW_CLASS (e_mail_shell_view_parent_class)-> update_actions (shell_view); shell_window = e_shell_view_get_shell_window (shell_view); mail_shell_view = E_MAIL_SHELL_VIEW (shell_view); mail_shell_content = mail_shell_view->priv->mail_shell_content; mail_view = e_mail_shell_content_get_mail_view (mail_shell_content); reader = E_MAIL_READER (mail_view); state = e_mail_reader_check_state (reader); e_mail_reader_update_actions (reader, state); mail_shell_sidebar = mail_shell_view->priv->mail_shell_sidebar; folder_tree = e_mail_shell_sidebar_get_folder_tree (mail_shell_sidebar); shell_sidebar = e_shell_view_get_shell_sidebar (shell_view); state = e_shell_sidebar_check_state (shell_sidebar); model = em_folder_tree_model_get_default (); folder_allows_children = (state & E_MAIL_SIDEBAR_FOLDER_ALLOWS_CHILDREN); folder_can_be_deleted = (state & E_MAIL_SIDEBAR_FOLDER_CAN_DELETE); folder_is_outbox = (state & E_MAIL_SIDEBAR_FOLDER_IS_OUTBOX); folder_is_store = (state & E_MAIL_SIDEBAR_FOLDER_IS_STORE); folder_is_trash = (state & E_MAIL_SIDEBAR_FOLDER_IS_TRASH); folder_is_virtual = (state & E_MAIL_SIDEBAR_FOLDER_IS_VIRTUAL); store_is_builtin = (state & E_MAIL_SIDEBAR_STORE_IS_BUILTIN); store_is_subscribable = (state & E_MAIL_SIDEBAR_STORE_IS_SUBSCRIBABLE); store_can_be_disabled = (state & E_MAIL_SIDEBAR_STORE_CAN_BE_DISABLED); if (em_folder_tree_get_selected (folder_tree, &store, &folder_name)) { GtkTreeRowReference *reference; CamelFolder *folder; folder_is_selected = TRUE; folder = e_mail_reader_ref_folder (reader); /* XXX If the user right-clicks on a folder other than what * the message list is showing, disable folder rename. * Between fetching the CamelFolder asynchronously and * knowing when NOT to move the folder tree selection * back to where it was to avoid cancelling the inline * folder tree editing, it's just too hairy to try to * get right. So we're punting. */ if (folder != NULL) { gchar *uri1, *uri2; uri1 = e_mail_folder_uri_from_folder (folder); uri2 = e_mail_folder_uri_build (store, folder_name); folder_tree_and_message_list_agree = (g_strcmp0 (uri1, uri2) == 0); g_free (uri1); g_free (uri2); g_object_unref (folder); } reference = em_folder_tree_model_get_row_reference ( model, store, folder_name); if (reference != NULL) { GtkTreePath *path; GtkTreeIter iter; path = gtk_tree_row_reference_get_path (reference); gtk_tree_model_get_iter ( GTK_TREE_MODEL (model), &iter, path); has_unread_mail ( GTK_TREE_MODEL (model), &iter, TRUE, &folder_has_unread, &folder_has_unread_rec); gtk_tree_path_free (path); } g_clear_object (&store); g_free (folder_name); folder_name = NULL; } /* Look for a CamelStore that supports subscriptions. */ list = em_folder_tree_model_list_stores (model); for (link = list; link != NULL; link = g_list_next (link)) { CamelStore *store = CAMEL_STORE (link->data); if (CAMEL_IS_SUBSCRIBABLE (store)) { any_store_is_subscribable = TRUE; break; } } g_list_free (list); action = ACTION (MAIL_ACCOUNT_DISABLE); sensitive = folder_is_store && store_can_be_disabled; gtk_action_set_sensitive (action, sensitive); action = ACTION (MAIL_ACCOUNT_EXPUNGE); sensitive = folder_is_trash; gtk_action_set_sensitive (action, sensitive); action = ACTION (MAIL_ACCOUNT_PROPERTIES); sensitive = folder_is_store && !store_is_builtin; gtk_action_set_sensitive (action, sensitive); action = ACTION (MAIL_ACCOUNT_REFRESH); sensitive = folder_is_store; gtk_action_set_sensitive (action, sensitive); action = ACTION (MAIL_FLUSH_OUTBOX); sensitive = folder_is_outbox; gtk_action_set_sensitive (action, sensitive); action = ACTION (MAIL_FOLDER_COPY); sensitive = folder_is_selected; gtk_action_set_sensitive (action, sensitive); action = ACTION (MAIL_FOLDER_DELETE); sensitive = folder_is_selected && folder_can_be_deleted; gtk_action_set_sensitive (action, sensitive); action = ACTION (MAIL_FOLDER_EXPUNGE); sensitive = folder_is_selected && !folder_is_virtual; gtk_action_set_sensitive (action, sensitive); action = ACTION (MAIL_FOLDER_MOVE); sensitive = folder_is_selected && folder_can_be_deleted; gtk_action_set_sensitive (action, sensitive); action = ACTION (MAIL_FOLDER_NEW); sensitive = folder_allows_children; gtk_action_set_sensitive (action, sensitive); action = ACTION (MAIL_FOLDER_PROPERTIES); sensitive = folder_is_selected; gtk_action_set_sensitive (action, sensitive); action = ACTION (MAIL_FOLDER_REFRESH); sensitive = folder_is_selected; gtk_action_set_sensitive (action, sensitive); action = ACTION (MAIL_FOLDER_RENAME); sensitive = folder_is_selected && folder_can_be_deleted && folder_tree_and_message_list_agree; gtk_action_set_sensitive (action, sensitive); action = ACTION (MAIL_FOLDER_SELECT_THREAD); sensitive = folder_is_selected; gtk_action_set_sensitive (action, sensitive); action = ACTION (MAIL_FOLDER_SELECT_SUBTHREAD); sensitive = folder_is_selected; gtk_action_set_sensitive (action, sensitive); action = ACTION (MAIL_FOLDER_UNSUBSCRIBE); sensitive = folder_is_selected && store_is_subscribable && !folder_is_virtual; gtk_action_set_sensitive (action, sensitive); action = ACTION (MAIL_FOLDER_MARK_ALL_AS_READ); sensitive = folder_is_selected && folder_has_unread; gtk_action_set_sensitive (action, sensitive); action = ACTION (MAIL_POPUP_FOLDER_MARK_ALL_AS_READ); sensitive = folder_is_selected && folder_has_unread_rec; gtk_action_set_visible (action, sensitive); action = ACTION (MAIL_MANAGE_SUBSCRIPTIONS); sensitive = folder_is_store && store_is_subscribable; gtk_action_set_sensitive (action, sensitive); action = ACTION (MAIL_TOOLS_SUBSCRIPTIONS); sensitive = any_store_is_subscribable; gtk_action_set_sensitive (action, sensitive); /* folder_is_store + folder_is_virtual == "Search Folders" */ action = ACTION (MAIL_VFOLDER_UNMATCHED_ENABLE); gtk_action_set_visible (action, folder_is_store && folder_is_virtual); e_mail_shell_view_update_popup_labels (mail_shell_view); }
list_item_t *list_search_text(list_t *list, char *text, int from_start, int info_only, int case_sensitive) { list_item_t *cur = NULL; gboolean good = FALSE; GtkTreeIter iter; char text_buf[strlen(text)+1]; int column0; int found; //fprintf(stderr, "-- SEARCH text='%s' info=%d\n", text, info_only); /* Find where the search should start from */ if ( list->search_path != NULL ) { /* Get path of previous successful search */ gtk_tree_model_get_iter(GTK_TREE_MODEL(list->store), &iter, list->search_path); /* Remove search result highlighting */ gtk_list_store_set(list->store, &iter, LIST_LINENO_BACKGROUND, NULL, -1); list_search_clear(list); /* Get next row. If end reached, wrap to first row */ good = gtk_tree_model_iter_next(GTK_TREE_MODEL(list->store), &iter); if ( ! good ) from_start = 1; } else { from_start = 1; } if ( from_start ) { good = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(list->store), &iter); } /* Return now if no valid start row found */ if ( ! good ) return NULL; /* Make all chars capitals if search is not case sensitive */ if ( ! case_sensitive ) { strcpy(text_buf, text); text = strupper(text_buf); } /* Search for text in Log list */ column0 = info_only ? LIST_INFO : LIST_DATE; found = 0; while ( good && (!found) ) { int column; char *str; str = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(list->store), &iter); g_free(str); for (column = column0; (column <= LIST_INFO) && (!found); column++) { gtk_tree_model_get(GTK_TREE_MODEL(list->store), &iter, column, &str, -1); if ( strstr2(str, text, case_sensitive) != NULL ) found = 1; } if ( ! found ) good = gtk_tree_model_iter_next(GTK_TREE_MODEL(list->store), &iter); } if ( found ) { gtk_list_store_set(list->store, &iter, LIST_LINENO_BACKGROUND, "black", -1); if ( ! row_is_visible(list->tree, &iter) ) scroll_to_row(list->tree, &iter); list->search_path = gtk_tree_model_get_path(GTK_TREE_MODEL(list->store), &iter); } return cur; }
void cal_print_get_events (gchar *buffer, guint32 julian, GUI *appGUI) { GtkTreePath *path; GtkTreeIter iter; GtkTreeModel *model; GSList *lnode; struct note *a; gint i; gchar *wbuf1, *wbuf2; gchar buf1[BUFFER_SIZE], buf2[BUFFER_SIZE]; GDate *date, *sdate; gint age, syear; guint32 tsk_julian; gint time; gint max_event_length; GRegex *reg; buffer[0] = '\0'; max_event_length = (config.cal_print_event_length + 2 > BUFFER_SIZE) ? BUFFER_SIZE : config.cal_print_event_length + 2; #ifdef TASKS_ENABLED /* tasks */ if (config.cal_print_tasks) { model = GTK_TREE_MODEL (appGUI->tsk->tasks_list_store); g_return_if_fail (model != NULL); path = gtk_tree_path_new_first (); while (gtk_tree_model_get_iter (model, &iter, path) == TRUE) { gtk_tree_model_get (model, &iter, TA_COLUMN_DUE_DATE_JULIAN, &tsk_julian, TA_COLUMN_CATEGORY, &wbuf1, -1); if (tsk_julian == julian && tasks_category_get_state (wbuf1, STATE_CALENDAR, appGUI) == TRUE) { gtk_tree_model_get (model, &iter, TA_COLUMN_DUE_TIME, &time, TA_COLUMN_SUMMARY, &wbuf2, -1); if (time >= 0) { g_snprintf (buf1, max_event_length, "\n[%02d:%02d] %s", time / 3600, time / 60 % 60, wbuf2); } else { g_snprintf (buf1, max_event_length, "\n%s", wbuf2); } g_strlcat (buffer, buf1, BUFFER_SIZE); g_free (wbuf2); } g_free (wbuf1); gtk_tree_path_next (path); } gtk_tree_path_free (path); } #endif /* TASKS_ENABLED */ #ifdef CONTACTS_ENABLED /* birthdays */ if (config.cal_print_birthdays) { model = GTK_TREE_MODEL (appGUI->cnt->contacts_list_store); g_return_if_fail (model != NULL); date = g_date_new (); g_return_if_fail (date != NULL); sdate = g_date_new_julian (julian); g_return_if_fail (sdate != NULL); syear = g_date_get_year (sdate); path = gtk_tree_path_new_first (); while (gtk_tree_model_get_iter (model, &iter, path) == TRUE) { gtk_tree_model_get (model, &iter, COLUMN_BIRTH_DAY_DATE, &tsk_julian, -1); if (g_date_valid_julian (tsk_julian)) { g_date_set_julian (date, tsk_julian); age = syear - g_date_get_year (date); if (age >= 0) { if (g_date_valid_dmy (g_date_get_day (date), g_date_get_month (date), syear) == FALSE) { g_date_subtract_days (date, 1); } g_date_set_year (date, syear); if (g_date_compare (date, sdate) == 0) { gtk_tree_model_get (model, &iter, COLUMN_FIRST_NAME, &wbuf1, COLUMN_LAST_NAME, &wbuf2, -1); utl_name_strcat (wbuf1, wbuf2, buf2); g_snprintf (buf1, max_event_length, "\n%s (%d)", buf2, age); g_strlcat (buffer, buf1, BUFFER_SIZE); } } } gtk_tree_path_next (path); } gtk_tree_path_free (path); g_date_free (sdate); g_date_free (date); } /* name days */ if (config.cal_print_namedays) { model = GTK_TREE_MODEL (appGUI->cnt->contacts_list_store); g_return_if_fail (model != NULL); date = NULL; date = g_date_new (); g_return_if_fail (date != NULL); sdate = NULL; sdate = g_date_new_julian (julian); g_return_if_fail (sdate != NULL); syear = g_date_get_year (sdate); path = gtk_tree_path_new_first (); while (gtk_tree_model_get_iter (model, &iter, path) == TRUE) { gtk_tree_model_get (model, &iter, COLUMN_NAME_DAY_DATE, &tsk_julian, -1); if (g_date_valid_julian (tsk_julian)) { g_date_set_julian (date, tsk_julian); if (g_date_valid_dmy (g_date_get_day (date), g_date_get_month (date), syear) == TRUE) { g_date_set_year (date, syear); if (g_date_compare (date, sdate) == 0) { gtk_tree_model_get (model, &iter, COLUMN_FIRST_NAME, &wbuf1, COLUMN_LAST_NAME, &wbuf2, -1); utl_name_strcat (wbuf1, wbuf2, buf1); g_snprintf (buf2, max_event_length, "\n%s (%s)", buf1, _("Name day")); g_strlcat (buffer, buf2, BUFFER_SIZE); } } } gtk_tree_path_next (path); } gtk_tree_path_free (path); g_date_free (sdate); g_date_free (date); } #endif /* CONTACTS_ENABLED */ /* day note */ if (config.cal_print_day_notes) { if (appGUI->cal->notes_list != NULL) { wbuf1 = NULL; reg = g_regex_new ("\n", 0, 0, NULL); for (i = 0, lnode = appGUI->cal->notes_list; lnode != NULL; lnode = lnode->next, i++) { a = g_slist_nth_data (appGUI->cal->notes_list, i); if (a->date == julian) { wbuf1 = g_regex_replace_literal (reg, a->note, -1, 0, " ", 0, NULL); break; } } g_regex_unref (reg); } if (wbuf1 != NULL) { g_strstrip (wbuf1); g_snprintf (buf1, max_event_length, "\n%s", wbuf1); g_strlcat (buffer, buf1, BUFFER_SIZE); g_free (wbuf1); } } #ifdef HAVE_LIBICAL /* ical */ if (config.cal_print_ical) { } #endif /* HAVE_LIBICAL */ g_strstrip (buffer); }
static gboolean exo_tree_view_single_click_timeout (gpointer user_data) { GtkTreeViewColumn *cursor_column; GtkTreeSelection *selection; GtkTreeModel *model; GtkTreePath *cursor_path; GtkTreeIter iter; ExoTreeView *tree_view = EXO_TREE_VIEW (user_data); gboolean hover_path_selected; GList *rows; GList *lp; //GDK_THREADS_ENTER (); //sfm not needed because called from g_idle? /* verify that we are in single-click mode, have focus and a hover path */ if (gtk_widget_has_focus (GTK_WIDGET (tree_view)) && tree_view->priv->single_click && tree_view->priv->hover_path != NULL) { /* transform the hover_path to a tree iterator */ model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view)); if (model != NULL && gtk_tree_model_get_iter (model, &iter, tree_view->priv->hover_path)) { /* determine the current cursor path/column */ gtk_tree_view_get_cursor (GTK_TREE_VIEW (tree_view), &cursor_path, &cursor_column); /* be sure the row is fully visible */ gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (tree_view), tree_view->priv->hover_path, 0, //sfm was cursor_column - caused horizontal scroll FALSE, 0.0f, 0.0f); /* determine the selection and change it appropriately */ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)); if (gtk_tree_selection_get_mode (selection) == GTK_SELECTION_NONE) { /* just place the cursor on the row */ gtk_tree_view_set_cursor (GTK_TREE_VIEW (tree_view), tree_view->priv->hover_path, cursor_column, FALSE); } else if ((tree_view->priv->single_click_timeout_state & GDK_SHIFT_MASK) != 0 && gtk_tree_selection_get_mode (selection) == GTK_SELECTION_MULTIPLE) { /* check if the item is not already selected (otherwise do nothing) */ if (!gtk_tree_selection_path_is_selected (selection, tree_view->priv->hover_path)) { /* unselect all previously selected items */ gtk_tree_selection_unselect_all (selection); /* since we cannot access the anchor of a GtkTreeView, we * use the cursor instead which is usually the same row. */ if (G_UNLIKELY (cursor_path == NULL)) { /* place the cursor on the new row */ gtk_tree_view_set_cursor (GTK_TREE_VIEW (tree_view), tree_view->priv->hover_path, cursor_column, FALSE); } else { /* select all between the cursor and the current row */ gtk_tree_selection_select_range (selection, tree_view->priv->hover_path, cursor_path); } } } else { /* remember the previously selected rows as set_cursor() clears the selection */ rows = gtk_tree_selection_get_selected_rows (selection, NULL); /* check if the hover path is selected (as it will be selected after the set_cursor() call) */ hover_path_selected = gtk_tree_selection_path_is_selected (selection, tree_view->priv->hover_path); /* place the cursor on the hover row */ gtk_tree_view_set_cursor (GTK_TREE_VIEW (tree_view), tree_view->priv->hover_path, cursor_column, FALSE); /* restore the previous selection */ for (lp = rows; lp != NULL; lp = lp->next) { gtk_tree_selection_select_path (selection, lp->data); gtk_tree_path_free (lp->data); } g_list_free (rows); /* check what to do */ if ((gtk_tree_selection_get_mode (selection) == GTK_SELECTION_MULTIPLE || (gtk_tree_selection_get_mode (selection) == GTK_SELECTION_SINGLE && hover_path_selected)) && (tree_view->priv->single_click_timeout_state & GDK_CONTROL_MASK) != 0) { /* toggle the selection state of the row */ if (G_UNLIKELY (hover_path_selected)) gtk_tree_selection_unselect_path (selection, tree_view->priv->hover_path); else gtk_tree_selection_select_path (selection, tree_view->priv->hover_path); } else if (G_UNLIKELY (!hover_path_selected)) { /* unselect all other rows */ gtk_tree_selection_unselect_all (selection); /* select only the hover row */ gtk_tree_selection_select_path (selection, tree_view->priv->hover_path); } } /* cleanup */ if (G_LIKELY (cursor_path != NULL)) gtk_tree_path_free (cursor_path); } } //GDK_THREADS_LEAVE (); return FALSE; }
static void combobox_changed (GtkComboBox *combobox, PanelRunDialog *dialog) { char *text; char *start; char *msg; text = g_strdup (panel_run_dialog_get_combo_text (dialog)); start = text; while (*start != '\0' && g_ascii_isspace (*start)) start++; /* update item name to use for dnd */ if (!dialog->use_program_list) { if (dialog->desktop_path) { g_free (dialog->desktop_path); dialog->desktop_path = NULL; } if (dialog->item_name) { g_free (dialog->item_name); dialog->item_name = NULL; } } /* desensitize run button if no text entered */ if (!start || !start [0]) { g_free (text); gtk_widget_set_sensitive (dialog->run_button, FALSE); gtk_drag_source_unset (dialog->run_dialog); if (panel_profile_get_enable_program_list ()) gtk_label_set_text (GTK_LABEL (dialog->program_label), _("Select an application to view its description.")); panel_run_dialog_set_default_icon (dialog, FALSE); if (dialog->find_command_idle_id) { g_source_remove (dialog->find_command_idle_id); dialog->find_command_idle_id = 0; } if (panel_profile_get_enable_program_list ()) { GtkTreeIter iter; GtkTreePath *path; gtk_tree_model_foreach (GTK_TREE_MODEL (dialog->program_list_store), panel_run_dialog_make_all_list_visible, NULL); path = gtk_tree_path_new_first (); if (gtk_tree_model_get_iter (gtk_tree_view_get_model (GTK_TREE_VIEW (dialog->program_list)), &iter, path)) gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (dialog->program_list), path, NULL, FALSE, 0, 0); gtk_tree_path_free (path); } return; } gtk_widget_set_sensitive (dialog->run_button, TRUE); gtk_drag_source_set (dialog->run_dialog, GDK_BUTTON1_MASK, NULL, 0, GDK_ACTION_COPY); gtk_drag_source_add_uri_targets (dialog->run_dialog); if (panel_profile_get_enable_program_list () && !dialog->use_program_list) { msg = g_strdup_printf (_("Will run command: '%s'"), start); gtk_label_set_text (GTK_LABEL (dialog->program_label), msg); g_free (msg); } /* look up icon for the command */ if (panel_profile_get_enable_program_list () && !dialog->use_program_list && !dialog->find_command_idle_id) dialog->find_command_idle_id = g_idle_add_full (G_PRIORITY_LOW, (GSourceFunc) panel_run_dialog_find_command_idle, dialog, NULL); g_free (text); }
static GList * get_remove_list(PdmActionInfo *action) { GList *l, *model_iters, *sorter_paths, *remove_list; GtkTreeModel *model, *sorter, *filter; GtkTreeSelection *selection; selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(action->treeview)); sorter_paths = gtk_tree_selection_get_selected_rows(selection, &sorter); /* We have our list of selected paths, update selection now to avoid * multiple signals when we start removing things. If only single row * was selected, attempt to select the next one below. No harm done if * it fails (we're not trying to select the row above because Evolution * isn't either.) */ gtk_tree_selection_unselect_all(selection); if (sorter_paths != NULL && sorter_paths->next == NULL) { GtkTreePath *select_path; select_path = gtk_tree_path_copy(sorter_paths->data); gtk_tree_path_next(select_path); gtk_tree_selection_select_path(selection, select_path); gtk_tree_path_free(select_path); } /* Paths are somewhat fragile, removing a row will invalidate all the * following paths (they will be referring to the row below the one * they used to) and you'll end up removing random items. Convert * paths to TreeIters which persist (at least with ListStore they do.) */ filter = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(sorter)); model = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(filter)); model_iters = NULL; for (l = sorter_paths; l != NULL; l = l->next) { GtkTreePath *sorter_path = l->data; GtkTreePath *filter_path, *model_path; GtkTreeIter iter; filter_path = gtk_tree_model_sort_convert_path_to_child_path (GTK_TREE_MODEL_SORT(sorter), sorter_path); model_path = gtk_tree_model_filter_convert_path_to_child_path (GTK_TREE_MODEL_FILTER(filter), filter_path); if (gtk_tree_model_get_iter(model, &iter, model_path)) { model_iters = g_list_prepend(model_iters, gtk_tree_iter_copy(&iter)); } gtk_tree_path_free(model_path); gtk_tree_path_free(filter_path); gtk_tree_path_free(sorter_path); } g_list_free(sorter_paths); /* It's now safe to turn off your computer... I mean, remove the rows. */ remove_list = NULL; for (l = model_iters; l != NULL; l = l->next) { GtkTreeIter *iter = l->data; GList *link; gpointer data; gtk_tree_model_get(model, iter, action->data_col, &data, -1); link = g_list_find(action->list, data); action->list = g_list_remove_link(action->list, link); remove_list = g_list_concat(link, remove_list); gtk_list_store_remove(GTK_LIST_STORE(model), iter); gtk_tree_iter_free(iter); } g_list_free(model_iters); return remove_list; }
static gboolean panel_run_dialog_find_command_idle (PanelRunDialog *dialog) { GtkTreeIter iter; GtkTreeModel *model; GtkTreePath *path; char *text; GIcon *found_icon; char *found_name; gboolean fuzzy; model = GTK_TREE_MODEL (dialog->program_list_store); path = gtk_tree_path_new_first (); if (!path || !gtk_tree_model_get_iter (model, &iter, path)) { if (path) gtk_tree_path_free (path); panel_run_dialog_set_icon (dialog, NULL, FALSE); dialog->find_command_idle_id = 0; return FALSE; } text = g_strdup (panel_run_dialog_get_combo_text (dialog)); found_icon = NULL; found_name = NULL; fuzzy = FALSE; do { char *exec = NULL; GIcon *icon = NULL; char *name = NULL; char *comment = NULL; gtk_tree_model_get (model, &iter, COLUMN_EXEC, &exec, COLUMN_GICON, &icon, COLUMN_NAME, &name, COLUMN_COMMENT, &comment, -1); if (!fuzzy && exec && icon && fuzzy_command_match (text, exec, &fuzzy)) { g_clear_object (&found_icon); g_free (found_name); found_icon = g_object_ref (icon); found_name = g_strdup (name); gtk_list_store_set (dialog->program_list_store, &iter, COLUMN_VISIBLE, TRUE, -1); } else if (panel_g_utf8_strstrcase (exec, text) != NULL || panel_g_utf8_strstrcase (name, text) != NULL || panel_g_utf8_strstrcase (comment, text) != NULL) { gtk_list_store_set (dialog->program_list_store, &iter, COLUMN_VISIBLE, TRUE, -1); } else { gtk_list_store_set (dialog->program_list_store, &iter, COLUMN_VISIBLE, FALSE, -1); } g_free (exec); g_object_unref (icon); g_free (name); g_free (comment); } while (gtk_tree_model_iter_next (model, &iter)); if (gtk_tree_model_get_iter (gtk_tree_view_get_model (GTK_TREE_VIEW (dialog->program_list)), &iter, path)) gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (dialog->program_list), path, NULL, FALSE, 0, 0); gtk_tree_path_free (path); panel_run_dialog_set_icon (dialog, found_icon, FALSE); //FIXME update dialog->program_label g_clear_object (&found_icon); g_free (text); g_free (dialog->item_name); dialog->item_name = found_name; dialog->find_command_idle_id = 0; return FALSE; }
static void ok_clicked_cb (GtkWidget *widget, DialogData *data) { char *s_value; GFile *destination; int i_value; const char *header; const char *footer; const char *image_page_header; const char *image_page_footer; char *thumbnail_caption; char *image_attributes; GtkTreeIter iter; char *theme_name; GthFileDataSort *sort_type; GthTask *task; /* save the options */ s_value = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (GET_WIDGET ("destination_filechooserbutton"))); destination = g_file_new_for_uri (s_value); _g_settings_set_uri (data->settings, PREF_WEBALBUMS_DESTINATION, s_value); g_free (s_value); g_settings_set_boolean (data->settings, PREF_WEBALBUMS_COPY_IMAGES, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("copy_images_checkbutton")))); g_settings_set_boolean (data->settings, PREF_WEBALBUMS_RESIZE_IMAGES, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("resize_images_checkbutton")))); i_value = gtk_combo_box_get_active (GTK_COMBO_BOX (GET_WIDGET ("resize_images_combobox"))); g_settings_set_int (data->settings, PREF_WEBALBUMS_RESIZE_WIDTH, ImageSizeValues[i_value].width); g_settings_set_int (data->settings, PREF_WEBALBUMS_RESIZE_HEIGHT, ImageSizeValues[i_value].height); g_settings_set_int (data->settings, PREF_WEBALBUMS_IMAGES_PER_INDEX, gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (GET_WIDGET ("images_per_index_spinbutton")))); g_settings_set_boolean (data->settings, PREF_WEBALBUMS_SINGLE_INDEX, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("single_index_checkbutton")))); g_settings_set_int (data->settings, PREF_WEBALBUMS_COLUMNS, gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (GET_WIDGET ("cols_spinbutton")))); g_settings_set_boolean (data->settings, PREF_WEBALBUMS_ADAPT_TO_WIDTH, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("adapt_column_checkbutton")))); if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (GET_WIDGET ("sort_combobox")), &iter)) { GthFileDataSort *sort_type; gtk_tree_model_get (GTK_TREE_MODEL (GET_WIDGET ("sort_liststore")), &iter, SORT_TYPE_COLUMN_DATA, &sort_type, -1); g_settings_set_string (data->settings, PREF_WEBALBUMS_SORT_TYPE, sort_type->name); } g_settings_set_boolean (data->settings, PREF_WEBALBUMS_SORT_INVERSE, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("reverse_order_checkbutton")))); header = gtk_entry_get_text (GTK_ENTRY (GET_WIDGET ("header_entry"))); g_settings_set_string (data->settings, PREF_WEBALBUMS_HEADER, header); footer = gtk_entry_get_text (GTK_ENTRY (GET_WIDGET ("footer_entry"))); g_settings_set_string (data->settings, PREF_WEBALBUMS_FOOTER, footer); image_page_header = gtk_entry_get_text (GTK_ENTRY (GET_WIDGET ("image_page_header_entry"))); g_settings_set_string (data->settings, PREF_WEBALBUMS_IMAGE_PAGE_HEADER, image_page_header); image_page_footer = gtk_entry_get_text (GTK_ENTRY (GET_WIDGET ("image_page_footer_entry"))); g_settings_set_string (data->settings, PREF_WEBALBUMS_IMAGE_PAGE_FOOTER, image_page_footer); theme_name = NULL; { GList *list; list = gtk_icon_view_get_selected_items (GTK_ICON_VIEW (GET_WIDGET ("theme_iconview"))); if (list != NULL) { GtkTreePath *path; GtkTreeIter iter; path = g_list_first (list)->data; gtk_tree_model_get_iter (GTK_TREE_MODEL (GET_WIDGET ("theme_liststore")), &iter, path); gtk_tree_model_get (GTK_TREE_MODEL (GET_WIDGET ("theme_liststore")), &iter, THEME_COLUMN_NAME, &theme_name, -1); } g_list_foreach (list, (GFunc) gtk_tree_path_free, NULL); g_list_free (list); } g_return_if_fail (theme_name != NULL); g_settings_set_string (data->settings, PREF_WEBALBUMS_THEME, theme_name); g_settings_set_boolean (data->settings, PREF_WEBALBUMS_ENABLE_THUMBNAIL_CAPTION, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("thumbnail_caption_checkbutton")))); thumbnail_caption = gth_metadata_chooser_get_selection (GTH_METADATA_CHOOSER (data->thumbnail_caption_chooser)); g_settings_set_string (data->settings, PREF_WEBALBUMS_THUMBNAIL_CAPTION, thumbnail_caption); g_settings_set_boolean (data->settings, PREF_WEBALBUMS_ENABLE_IMAGE_ATTRIBUTES, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("image_attributes_checkbutton")))); g_settings_set_boolean (data->settings, PREF_WEBALBUMS_ENABLE_IMAGE_DESCRIPTION, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("image_description_checkbutton")))); image_attributes = gth_metadata_chooser_get_selection (GTH_METADATA_CHOOSER (data->image_attributes_chooser)); g_settings_set_string (data->settings, PREF_WEBALBUMS_IMAGE_ATTRIBUTES, image_attributes); /* exec the task */ task = gth_web_exporter_new (data->browser, data->file_list); gth_web_exporter_set_header (GTH_WEB_EXPORTER (task), header); gth_web_exporter_set_footer (GTH_WEB_EXPORTER (task), footer); gth_web_exporter_set_image_page_header (GTH_WEB_EXPORTER (task), image_page_header); gth_web_exporter_set_image_page_footer (GTH_WEB_EXPORTER (task), image_page_footer); gth_web_exporter_set_style (GTH_WEB_EXPORTER (task), theme_name); gth_web_exporter_set_destination (GTH_WEB_EXPORTER (task), destination); gth_web_exporter_set_copy_images (GTH_WEB_EXPORTER (task), g_settings_get_boolean (data->settings, PREF_WEBALBUMS_COPY_IMAGES)); gth_web_exporter_set_resize_images (GTH_WEB_EXPORTER (task), g_settings_get_boolean (data->settings, PREF_WEBALBUMS_RESIZE_IMAGES), g_settings_get_int (data->settings, PREF_WEBALBUMS_RESIZE_WIDTH), g_settings_get_int (data->settings, PREF_WEBALBUMS_RESIZE_HEIGHT)); s_value = g_settings_get_string (data->settings, PREF_WEBALBUMS_SORT_TYPE); sort_type = gth_main_get_sort_type (s_value); gth_web_exporter_set_sort_order (GTH_WEB_EXPORTER (task), sort_type, g_settings_get_boolean (data->settings, PREF_WEBALBUMS_SORT_INVERSE)); g_free (s_value); gth_web_exporter_set_images_per_index (GTH_WEB_EXPORTER (task), g_settings_get_int (data->settings, PREF_WEBALBUMS_IMAGES_PER_INDEX)); gth_web_exporter_set_single_index (GTH_WEB_EXPORTER (task), g_settings_get_boolean (data->settings, PREF_WEBALBUMS_SINGLE_INDEX)); gth_web_exporter_set_columns (GTH_WEB_EXPORTER (task), g_settings_get_int (data->settings, PREF_WEBALBUMS_COLUMNS)); gth_web_exporter_set_adapt_to_width (GTH_WEB_EXPORTER (task), g_settings_get_boolean (data->settings, PREF_WEBALBUMS_ADAPT_TO_WIDTH)); gth_web_exporter_set_thumbnail_caption (GTH_WEB_EXPORTER (task), gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("thumbnail_caption_checkbutton"))) ? thumbnail_caption : ""); gth_web_exporter_set_image_attributes (GTH_WEB_EXPORTER (task), gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("image_description_checkbutton"))), gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("image_attributes_checkbutton"))) ? image_attributes : ""); gth_browser_exec_task (data->browser, task, FALSE); gtk_widget_destroy (data->dialog); g_object_unref (task); g_free (image_attributes); g_free (thumbnail_caption); g_free (theme_name); g_object_unref (destination); }
/** * Drag-and-drop received. */ static void signal_dnd_recv(GtkTreeView *tv, GdkDragContext *context, int x, int y, GtkSelectionData *selection, guint info, guint time, gpointer data) { GDeviceSetup *gds; GtkTreeModel *model; GtkTreeSelection *sel; GtkTreeIter sel_iter, dest_iter, parent, ins_iter, *final_parent, *final_sib; GtkTreePath *path; GtkTreeViewDropPosition pos; int id, md_id; int use, md_use; gboolean status = False; gds = (GDeviceSetup*)data; model = gtk_tree_view_get_model(tv); sel = gtk_tree_view_get_selection(tv); if (!gtk_tree_selection_get_selected(sel, NULL, &sel_iter)) return; gtk_tree_model_get(model, &sel_iter, COL_ID, &id, COL_USE, &use, -1); /* MD selected? */ if (use == XIMasterPointer || use == XIMasterKeyboard) return; if (!gtk_tree_view_get_dest_row_at_pos(tv, x, y, &path, &pos)) return; gtk_tree_model_get_iter(model, &dest_iter, path); /* check for parent, set final_parent to parent and final_sib to the * sibling we're dropping onto. */ if (!gtk_tree_model_iter_parent(model, &parent, &dest_iter)) { final_parent = &dest_iter; final_sib = NULL; } else { final_parent = &parent; final_sib = &dest_iter; } gtk_tree_model_get(GTK_TREE_MODEL(model), final_parent, COL_ID, &md_id, COL_USE, &md_use, -1); g_debug("Trying to attach %d to %d\n", id, md_id); /* try */ if(md_id == ID_FLOATING) status = float_device(gds, id); else status = change_attachment(gds, id, md_id); if(status) toggle_undo_button(gds, TRUE); }
void chmod_dialog (GtkAction * a, gpointer data) { GtkWidget *tempwid, *dialog, *hbox, *vbox; GList * templist; gftp_window_data * wdata; gftp_file * tempfle; wdata = data; if (!check_status (_("Chmod"), wdata, gftpui_common_use_threads (wdata->request), 0, 1, wdata->request->chmod != NULL)) return; dialog = gtk_dialog_new_with_buttons (_("Chmod"), GTK_WINDOW(window), 0, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area(GTK_DIALOG (dialog))), 5); gtk_container_set_border_width (GTK_CONTAINER (gtk_dialog_get_content_area(GTK_DIALOG (dialog))), 10); tempwid = gtk_label_new (_("You can now adjust the attributes of your file(s)\nNote: Not all ftp servers support the chmod feature")); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area(GTK_DIALOG (dialog))), tempwid, FALSE, FALSE, 0); gtk_widget_show (tempwid); hbox = gtk_hbox_new (TRUE, 5); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area(GTK_DIALOG (dialog))), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); tempwid = gtk_frame_new (_("Special")); gtk_box_pack_start (GTK_BOX (hbox), tempwid, FALSE, FALSE, 0); gtk_widget_show (tempwid); vbox = gtk_vbox_new (TRUE, 5); gtk_container_add (GTK_CONTAINER (tempwid), vbox); gtk_widget_show (vbox); suid = gtk_check_button_new_with_label (_("SUID")); gtk_box_pack_start (GTK_BOX (vbox), suid, FALSE, FALSE, 0); gtk_widget_show (suid); sgid = gtk_check_button_new_with_label (_("SGID")); gtk_box_pack_start (GTK_BOX (vbox), sgid, FALSE, FALSE, 0); gtk_widget_show (sgid); sticky = gtk_check_button_new_with_label (_("Sticky")); gtk_box_pack_start (GTK_BOX (vbox), sticky, FALSE, FALSE, 0); gtk_widget_show (sticky); tempwid = gtk_frame_new (_("User")); gtk_box_pack_start (GTK_BOX (hbox), tempwid, FALSE, FALSE, 0); gtk_widget_show (tempwid); vbox = gtk_vbox_new (TRUE, 5); gtk_container_add (GTK_CONTAINER (tempwid), vbox); gtk_widget_show (vbox); ur = gtk_check_button_new_with_label (_("Read")); gtk_box_pack_start (GTK_BOX (vbox), ur, FALSE, FALSE, 0); gtk_widget_show (ur); uw = gtk_check_button_new_with_label (_("Write")); gtk_box_pack_start (GTK_BOX (vbox), uw, FALSE, FALSE, 0); gtk_widget_show (uw); ux = gtk_check_button_new_with_label (_("Execute")); gtk_box_pack_start (GTK_BOX (vbox), ux, FALSE, FALSE, 0); gtk_widget_show (ux); tempwid = gtk_frame_new (_("Group")); gtk_box_pack_start (GTK_BOX (hbox), tempwid, FALSE, FALSE, 0); gtk_widget_show (tempwid); vbox = gtk_vbox_new (TRUE, 5); gtk_container_add (GTK_CONTAINER (tempwid), vbox); gtk_widget_show (vbox); gr = gtk_check_button_new_with_label (_("Read")); gtk_box_pack_start (GTK_BOX (vbox), gr, FALSE, FALSE, 0); gtk_widget_show (gr); gw = gtk_check_button_new_with_label (_("Write")); gtk_box_pack_start (GTK_BOX (vbox), gw, FALSE, FALSE, 0); gtk_widget_show (gw); gx = gtk_check_button_new_with_label (_("Execute")); gtk_box_pack_start (GTK_BOX (vbox), gx, FALSE, FALSE, 0); gtk_widget_show (gx); tempwid = gtk_frame_new (_("Other")); gtk_box_pack_start (GTK_BOX (hbox), tempwid, FALSE, FALSE, 0); gtk_widget_show (tempwid); vbox = gtk_vbox_new (TRUE, 5); gtk_container_add (GTK_CONTAINER (tempwid), vbox); gtk_widget_show (vbox); or = gtk_check_button_new_with_label (_("Read")); gtk_box_pack_start (GTK_BOX (vbox), or, FALSE, FALSE, 0); gtk_widget_show (or); ow = gtk_check_button_new_with_label (_("Write")); gtk_box_pack_start (GTK_BOX (vbox), ow, FALSE, FALSE, 0); gtk_widget_show (ow); ox = gtk_check_button_new_with_label (_("Execute")); gtk_box_pack_start (GTK_BOX (vbox), ox, FALSE, FALSE, 0); gtk_widget_show (ox); GtkTreeSelection *select; GtkTreeIter iter; GtkTreeModel * model; select = gtk_tree_view_get_selection (GTK_TREE_VIEW (wdata->listbox)); if (gtk_tree_selection_count_selected_rows(select) == 1) { templist = gtk_tree_selection_get_selected_rows(select, &model); gtk_tree_model_get_iter(model, &iter, (GtkTreePath*)templist->data); gtk_tree_model_get(model, &iter, 0, &tempfle, -1); g_list_foreach (templist, (GFunc) gtk_tree_path_free, NULL); g_list_free (templist); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (suid), tempfle->st_mode & S_ISUID); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ur), tempfle->st_mode & S_IRUSR); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (uw), tempfle->st_mode & S_IWUSR); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ux), tempfle->st_mode & S_IXUSR); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (sgid), tempfle->st_mode & S_ISGID); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (gr), tempfle->st_mode & S_IRGRP); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (gw), tempfle->st_mode & S_IWGRP); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (gx), tempfle->st_mode & S_IXGRP); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (sticky), tempfle->st_mode & S_ISVTX); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (or), tempfle->st_mode & S_IROTH); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ow), tempfle->st_mode & S_IWOTH); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ox), tempfle->st_mode & S_IXOTH); } gtk_dialog_set_default_response (GTK_DIALOG(dialog), GTK_RESPONSE_OK); gint response = gtk_dialog_run (GTK_DIALOG(dialog)); if (response == GTK_RESPONSE_OK) { dochmod (wdata); } gtk_widget_destroy (dialog); }
void _camera_import_dialog_run(_camera_import_dialog_t *data) { gtk_widget_show_all(data->dialog); // Populate store // Setup a listener for previews of all files on camera // then initiate fetch of all previews from camera if(data->params->camera!=NULL) { /* setup a camctl listener */ dt_camctl_listener_t listener= {0}; listener.data=data; listener.control_status=_control_status; listener.camera_storage_image_filename=_camera_storage_image_filename; dt_job_t job; dt_camera_get_previews_job_init(&job,data->params->camera, &listener, CAMCTL_IMAGE_PREVIEW_DATA); dt_control_job_set_state_callback(&job,_preview_job_state_changed,data); dt_control_add_job(darktable.control, &job); } else return; // Lets run dialog gtk_label_set_text(GTK_LABEL(data->import.info),_("select the images from the list below that you want to import into a new filmroll")); gboolean all_good=FALSE; g_signal_connect(G_OBJECT(data->dialog),"delete-event",G_CALLBACK(_dialog_close),data); while(!all_good) { gint result = gtk_dialog_run (GTK_DIALOG (data->dialog)); if( result == GTK_RESPONSE_ACCEPT) { GtkTreeIter iter; all_good=TRUE; GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(gtk_bin_get_child(GTK_BIN(data->import.treeview)))); // Now build up result from store into GList **result if(data->params->result) g_list_free(data->params->result); data->params->result=NULL; GtkTreeModel *model=GTK_TREE_MODEL(data->store); GList *sp= gtk_tree_selection_get_selected_rows(selection,&model); if( sp ) { do { GValue value = { 0, }; gtk_tree_model_get_iter(GTK_TREE_MODEL (data->store),&iter,(GtkTreePath*)sp->data); gtk_tree_model_get_value(GTK_TREE_MODEL (data->store),&iter,1,&value); if (G_VALUE_HOLDS_STRING (&value)) data->params->result = g_list_append(data->params->result,g_strdup(g_value_get_string(&value)) ); } while( (sp=g_list_next(sp)) ); } // Lets check jobcode, basedir etc.. data->params->jobcode = data->import.jobname->value; data->params->basedirectory = data->settings.basedirectory->value; data->params->subdirectory = data->settings.subdirectory->value; data->params->filenamepattern = data->settings.namepattern->value; data->params->time_override = 0; if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->settings.general.date_override))) data->params->time_override = parse_date_time(gtk_entry_get_text(GTK_ENTRY(data->settings.general.date_entry))); if( data->params->jobcode == NULL || strlen(data->params->jobcode) <=0 ) data->params->jobcode = dt_conf_get_string("plugins/capture/camera/import/jobcode"); if( data->params->basedirectory == NULL || strlen( data->params->basedirectory ) <= 0 ) { GtkWidget *dialog=gtk_message_dialog_new(NULL,GTK_DIALOG_DESTROY_WITH_PARENT,GTK_MESSAGE_ERROR,GTK_BUTTONS_OK,_("please set the basedirectory settings before importing")); g_signal_connect_swapped (dialog, "response",G_CALLBACK (gtk_widget_destroy),dialog); gtk_dialog_run (GTK_DIALOG (dialog)); all_good=FALSE; } else if( data->params->subdirectory == NULL || strlen( data->params->subdirectory ) <= 0 ) { GtkWidget *dialog=gtk_message_dialog_new(NULL,GTK_DIALOG_DESTROY_WITH_PARENT,GTK_MESSAGE_ERROR,GTK_BUTTONS_OK,_("please set the subdirectory settings before importing")); g_signal_connect_swapped (dialog, "response",G_CALLBACK (gtk_widget_destroy),dialog); gtk_dialog_run (GTK_DIALOG (dialog)); all_good=FALSE; } else if( data->params->filenamepattern == NULL || strlen( data->params->filenamepattern ) <= 0 ) { GtkWidget *dialog=gtk_message_dialog_new(NULL,GTK_DIALOG_DESTROY_WITH_PARENT,GTK_MESSAGE_ERROR,GTK_BUTTONS_OK,_("please set the filenamepattern settings before importing")); g_signal_connect_swapped (dialog, "response",G_CALLBACK (gtk_widget_destroy),dialog); gtk_dialog_run (GTK_DIALOG (dialog)); all_good=FALSE; } else if( gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->settings.general.date_override)) && data->params->time_override == 0) { GtkWidget *dialog=gtk_message_dialog_new(NULL,GTK_DIALOG_DESTROY_WITH_PARENT,GTK_MESSAGE_ERROR,GTK_BUTTONS_OK,_("please use YYYY-MM-DD format for date override")); g_signal_connect_swapped (dialog, "response",G_CALLBACK (gtk_widget_destroy),dialog); gtk_dialog_run (GTK_DIALOG (dialog)); all_good=FALSE; } } else { data->params->result=NULL; all_good=TRUE; } } // Destroy and quit gtk_widget_destroy (data->dialog); }
static gboolean display_desktop_select(GtkTreeSelection *selection, GtkTreeModel *model, GtkTreePath *path, gboolean path_currently_selected, void *data) { int path_newly_selected = path_currently_selected ? 0:1; display_t *d = NULL; frame_hdr_t *frame = NULL; GtkTreeIter iter; if ( path_newly_selected ) { if ( gtk_tree_model_get_iter(model, &iter, path) ) { gtk_tree_model_get(model, &iter, DESKTOP_TREE_DISPLAY, &d, DESKTOP_TREE_FRAME, &frame, -1); } } /* Manage desktop switch */ if ( (d != NULL) && (d != display_current) ) { display_t *display_previous; /* Select new desktop */ display_previous = display_current; display_current = d; display_current_iter = iter; /* Disconnect previously selected desktop */ display_disconnect(display_previous); debug(DEBUG_FRAME, "SELECT DESKTOP name='%s'\n", d->desktop.name); /* Start connection if display is available */ if ( d->desktop.available ) { if ( display_connect(d) ) display_desktop_available(d, 0); } /* Show jammed screen if display not available */ else { display_setup(d); } } if ( (frame != NULL) && (frame != display_current_frame) ) { display_current_frame = frame; display_current_frame_iter = iter; debug(DEBUG_FRAME, "SELECT FRAME id='%s'\n", frame->id); display_desktop_map_layers(&(display_current->desktop)); display_refresh(display_current, &(display_current->desktop.root.g0)); display_selection_show(display_current); display_pattern_set_frame(frame); display_screenshot_set_frame(frame); display_desktop_highlight_frame(frame); } return TRUE; }
TILP_EXPORT gboolean on_treeview1_button_press_event(GtkWidget * widget, GdkEventButton * event, gpointer user_data) { GtkTreeView *view = GTK_TREE_VIEW(ctree_wnd); GtkTreeModel *model = GTK_TREE_MODEL(tree); GtkTreePath *path; GtkTreeViewColumn *column; GtkTreeIter parent; VarEntry *ve; gint tx = (gint) event->x; gint ty = (gint) event->y; gint cx, cy; gtk_tree_view_get_path_at_pos(view, tx, ty, &path, &column, &cx, &cy); if (path == NULL) return FALSE; gtk_tree_model_get_iter(model, &parent, path); gtk_tree_model_get(model, &parent, COLUMN_DATA, &ve, -1); path_to_drag = path; gtk_tree_model_get(model, &parent, COLUMN_NAME, &name_to_drag, -1); if(event->type == GDK_BUTTON_PRESS) { if(event->button == 1) { /* printf("clicked !\n"); ctree_select_vars(!0); printf("selected ?!\n"); */ } else if (event->button == 3) { GdkEventButton *bevent = (GdkEventButton *) (event); gtk_menu_popup(GTK_MENU(create_ctree_rbm()), NULL, NULL, NULL, NULL, bevent->button, bevent->time); return TRUE; } } if (event->type == GDK_2BUTTON_PRESS) { gchar *name; gtk_tree_model_get(model, &parent, COLUMN_NAME, &name, -1); if (!strcmp(name, NODE1)) display_screenshot_dbox(); else if (!strcmp(name, NODE2)) on_rom_dump1_activate(NULL, NULL); else if (!strcmp(name, NODE3)) on_tilp_button3_clicked(NULL, NULL); else if(!strcmp(name, NODE5)) tilp_calc_idlist(0); else if(!strcmp(name, NODE6)) display_clock_dbox(); else if(!strncmp(name, tifiles_model_to_string(options.calc_model), 4)) { CalcInfos infos; tilp_calc_get_infos(&infos); } return TRUE; } if (ve == NULL) return FALSE; if (ve->type != tifiles_folder_type(options.calc_model)) return FALSE; name_to_drag = NODEx; return FALSE; // pass the event on }
static void bar_pane_keywords_dnd_receive(GtkWidget *tree_view, GdkDragContext *context, gint x, gint y, GtkSelectionData *selection_data, guint info, guint time, gpointer data) { PaneKeywordsData *pkd = data; GtkTreePath *tpath = NULL; GtkTreeViewDropPosition pos; GtkTreeModel *model; GtkTreeModel *keyword_tree; gboolean src_valid = FALSE; GList *new_keywords = NULL; GList *work; /* iterators for keyword_tree */ GtkTreeIter src_kw_iter; GtkTreeIter dest_kw_iter; GtkTreeIter new_kw_iter; g_signal_stop_emission_by_name(tree_view, "drag_data_received"); model = gtk_tree_view_get_model(GTK_TREE_VIEW(tree_view)); keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model)); gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(tree_view), x, y, &tpath, &pos); gtk_tree_view_set_drag_dest_row(GTK_TREE_VIEW(tree_view), NULL, pos); switch (info) { case TARGET_APP_KEYWORD_PATH: { GList *path = *(gpointer *)selection_data->data; src_valid = keyword_tree_get_iter(keyword_tree, &src_kw_iter, path); string_list_free(path); break; } default: new_keywords = string_to_keywords_list((gchar *)selection_data->data); break; } if (tpath) { GtkTreeIter dest_iter; gtk_tree_model_get_iter(model, &dest_iter, tpath); gtk_tree_path_free(tpath); gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &dest_kw_iter, &dest_iter); if (src_valid && gtk_tree_store_is_ancestor(GTK_TREE_STORE(keyword_tree), &src_kw_iter, &dest_kw_iter)) { /* can't move to it's own child */ return; } if (src_valid && keyword_compare(keyword_tree, &src_kw_iter, &dest_kw_iter) == 0) { /* can't move to itself */ return; } if ((pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE || pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER) && !gtk_tree_model_iter_has_child(keyword_tree, &dest_kw_iter)) { /* the node has no children, all keywords can be added */ gtk_tree_store_append(GTK_TREE_STORE(keyword_tree), &new_kw_iter, &dest_kw_iter); } else { if (src_valid && !bar_pane_keywords_dnd_can_move(keyword_tree, &src_kw_iter, &dest_kw_iter)) { /* the keyword can't be moved if the same name already exist */ return; } if (new_keywords && !bar_pane_keywords_dnd_skip_existing(keyword_tree, &dest_kw_iter, &new_keywords)) { /* the keywords can't be added if the same name already exist */ return; } switch (pos) { case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE: case GTK_TREE_VIEW_DROP_BEFORE: gtk_tree_store_insert_before(GTK_TREE_STORE(keyword_tree), &new_kw_iter, NULL, &dest_kw_iter); break; case GTK_TREE_VIEW_DROP_INTO_OR_AFTER: case GTK_TREE_VIEW_DROP_AFTER: gtk_tree_store_insert_after(GTK_TREE_STORE(keyword_tree), &new_kw_iter, NULL, &dest_kw_iter); break; } } } else { if (src_valid && !bar_pane_keywords_dnd_can_move(keyword_tree, &src_kw_iter, NULL)) { /* the keyword can't be moved if the same name already exist */ return; } if (new_keywords && !bar_pane_keywords_dnd_skip_existing(keyword_tree, NULL, &new_keywords)) { /* the keywords can't be added if the same name already exist */ return; } gtk_tree_store_append(GTK_TREE_STORE(keyword_tree), &new_kw_iter, NULL); } if (src_valid) { keyword_move_recursive(GTK_TREE_STORE(keyword_tree), &new_kw_iter, &src_kw_iter); } work = new_keywords; while (work) { gchar *keyword = work->data; keyword_set(GTK_TREE_STORE(keyword_tree), &new_kw_iter, keyword, TRUE); work = work->next; if (work) { GtkTreeIter add; gtk_tree_store_insert_after(GTK_TREE_STORE(keyword_tree), &add, NULL, &new_kw_iter); new_kw_iter = add; } } string_list_free(new_keywords); bar_keyword_tree_sync(pkd); }
static void resolve_t_param_cb (SoupSession *session, SoupMessage *message, TParamData *data) { gchar *video_uri = NULL; const gchar *video_id, *contents; gsize length; GMatchInfo *match_info; GtkTreeIter iter; TotemYouTubePlugin *self = data->plugin; /* Prevent cancellation */ g_cancellable_disconnect (data->cancellable, data->cancelled_id); /* Finish loading the page */ if (message->status_code != SOUP_STATUS_OK) { GtkWindow *window; /* Bail out if the operation was cancelled */ if (message->status_code == SOUP_STATUS_CANCELLED) goto free_data; /* Couldn't load the page contents; error */ window = totem_get_main_window (data->plugin->totem); totem_interface_error (_("Error Looking Up Video URI"), message->response_body->data, window); g_object_unref (window); goto free_data; } contents = message->response_body->data; length = message->response_body->length; video_id = gdata_youtube_video_get_video_id (GDATA_YOUTUBE_VIDEO (data->entry)); /* Check for the fmt_url_map parameter */ g_regex_match (self->regex, contents, 0, &match_info); if (g_match_info_matches (match_info) == TRUE) { gchar *fmt_url_map_escaped, *fmt_url_map; gchar **mappings, **i; GHashTable *fmt_table; gint connection_speed; /* We have a match */ fmt_url_map_escaped = g_match_info_fetch (match_info, 1); fmt_url_map = g_uri_unescape_string (fmt_url_map_escaped, NULL); g_free (fmt_url_map_escaped); /* The fmt_url_map parameter is in the following format: * fmt1|uri1,fmt2|uri2,fmt3|uri3,... * where fmtN is an identifier for the audio and video encoding and resolution as described here: * (http://en.wikipedia.org/wiki/YouTube#Quality_and_codecs) and uriN is the playback URI for that format. * * We parse it into a hash table from format to URI, and use that against a ranked list of preferred formats (based on the user's * connection speed) to determine the URI to use. */ fmt_table = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, g_free); mappings = g_strsplit (fmt_url_map, ",", 0); for (i = mappings; *i != NULL; i++) { /* For the moment we just take the first format we get */ gchar **mapping; gint fmt; mapping = g_strsplit (*i, "|", 2); if (mapping[0] == NULL || mapping[1] == NULL) { g_warning ("Bad format-URI mapping: %s", *i); g_strfreev (mapping); continue; } fmt = atoi (mapping[0]); if (fmt < 1) { g_warning ("Badly-formed format: %s", mapping[0]); g_strfreev (mapping); continue; } g_hash_table_insert (fmt_table, GUINT_TO_POINTER ((guint) fmt), g_strdup (mapping[1])); g_strfreev (mapping); } g_strfreev (mappings); /* Starting with the highest connection speed we support, look for video URIs matching our connection speed. */ connection_speed = MIN (bacon_video_widget_get_connection_speed (self->bvw), (gint) G_N_ELEMENTS (fmt_preferences) - 1); for (; connection_speed >= 0; connection_speed--) { guint idx = (guint) connection_speed; video_uri = g_strdup (g_hash_table_lookup (fmt_table, GUINT_TO_POINTER (fmt_preferences [idx]))); /* Have we found a match yet? */ if (video_uri != NULL) { g_debug ("Using video URI for format %u (connection speed %u)", fmt_preferences[idx], idx); break; } } g_hash_table_destroy (fmt_table); } /* Fallback */ if (video_uri == NULL) { GDataMediaContent *content; /* We don't have a match, which is odd; fall back to the FLV URI as advertised by the YouTube API */ content = GDATA_MEDIA_CONTENT (gdata_youtube_video_look_up_content (GDATA_YOUTUBE_VIDEO (data->entry), "application/x-shockwave-flash")); if (content != NULL) { video_uri = g_strdup (gdata_media_content_get_uri (content)); g_debug ("Couldn't find the t param of entry %s; falling back to its FLV URI (\"%s\")", video_id, video_uri); } else { /* Cop out */ g_warning ("Couldn't find the t param of entry %s or its FLV URI.", video_uri); video_uri = NULL; } } g_match_info_free (match_info); /* Update the tree view with the new MRL */ if (gtk_tree_model_get_iter (GTK_TREE_MODEL (self->list_store[data->tree_view]), &iter, data->path) == TRUE) { gtk_list_store_set (self->list_store[data->tree_view], &iter, 2, video_uri, -1); g_debug ("Updated list store with new video URI (\"%s\") for entry %s", video_uri, video_id); } g_free (video_uri); free_data: /* Update the progress bar */ increment_progress_bar_fraction (self, data->tree_view); g_object_unref (data->cancellable); g_object_unref (data->plugin); g_object_unref (data->entry); gtk_tree_path_free (data->path); g_slice_free (TParamData, data); }
static void bar_pane_keywords_edit_dialog(PaneKeywordsData *pkd, gboolean edit_existing) { ConfDialogData *cdd; GenericDialog *gd; GtkWidget *table; GtkWidget *group; GtkWidget *button; gchar *name = NULL; gboolean is_keyword = TRUE; if (edit_existing && pkd->click_tpath) { GtkTreeModel *model; GtkTreeIter iter; model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview)); if (gtk_tree_model_get_iter(model, &iter, pkd->click_tpath)) { gtk_tree_model_get(model, &iter, FILTER_KEYWORD_COLUMN_NAME, &name, FILTER_KEYWORD_COLUMN_IS_KEYWORD, &is_keyword, -1); } else { return; } } if (edit_existing && !name) return; cdd = g_new0(ConfDialogData, 1); cdd->pkd =pkd; cdd->click_tpath = pkd->click_tpath; pkd->click_tpath = NULL; cdd->edit_existing = edit_existing; cdd->gd = gd = generic_dialog_new(name ? _("Edit keyword") : _("Add keywords"), "keyword_edit", pkd->widget, TRUE, bar_pane_keywords_edit_cancel_cb, cdd); g_signal_connect(G_OBJECT(gd->dialog), "destroy", G_CALLBACK(bar_pane_keywords_edit_destroy_cb), cdd); generic_dialog_add_message(gd, NULL, name ? _("Configure keyword") : _("Add keyword"), NULL); generic_dialog_add_button(gd, GTK_STOCK_OK, NULL, bar_pane_keywords_edit_ok_cb, TRUE); table = pref_table_new(gd->vbox, 3, 1, FALSE, TRUE); pref_table_label(table, 0, 0, _("Keyword:"), 1.0); cdd->edit_widget = gtk_entry_new(); gtk_widget_set_size_request(cdd->edit_widget, 300, -1); if (name) gtk_entry_set_text(GTK_ENTRY(cdd->edit_widget), name); gtk_table_attach_defaults(GTK_TABLE(table), cdd->edit_widget, 1, 2, 0, 1); /* here could eventually be a text view instead of entry */ generic_dialog_attach_default(gd, cdd->edit_widget); gtk_widget_show(cdd->edit_widget); group = pref_group_new(gd->vbox, FALSE, _("Keyword type:"), GTK_ORIENTATION_VERTICAL); button = pref_radiobutton_new(group, NULL, _("Active keyword"), (is_keyword), G_CALLBACK(bar_pane_keywords_conf_set_kw), cdd); button = pref_radiobutton_new(group, button, _("Helper"), (!is_keyword), G_CALLBACK(bar_pane_keywords_conf_set_helper), cdd); cdd->is_keyword = is_keyword; g_free(name); gtk_widget_grab_focus(cdd->edit_widget); gtk_widget_show(gd->dialog); }
static gboolean prefswindow_row_selected(GtkTreeSelection *selector, GtkTreeModel *model, GtkTreePath *path, gboolean currently_selected, gpointer data) { PrefsTreeNode *prefsnode; PrefsPage *page; PrefsWindow *prefswindow = (PrefsWindow *) data; gfloat lower; gchar *labeltext; gint pagenum, i; GtkTreeIter iter; GtkAdjustment *adj; #ifndef GENERIC_UMPC if (currently_selected) return TRUE; #endif if (!gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &iter, path)) return TRUE; gtk_tree_model_get(model, &iter, PREFS_PAGE_DATA, &prefsnode, -1); page = prefsnode->page; debug_print("%f\n", prefsnode->treeweight); if (page == NULL) { gtk_label_set_text(GTK_LABEL(prefswindow->pagelabel), ""); pagenum = gtk_notebook_page_num(GTK_NOTEBOOK(prefswindow->notebook), prefswindow->empty_page); gtk_notebook_set_current_page(GTK_NOTEBOOK(prefswindow->notebook), pagenum); return TRUE; } prefswindow_build_page(prefswindow, page); i = 0; while (page->path[i + 1] != 0) i++; labeltext = page->path[i]; gtk_label_set_text(GTK_LABEL(prefswindow->pagelabel), labeltext); pagenum = gtk_notebook_page_num(GTK_NOTEBOOK(prefswindow->notebook), page->widget); gtk_notebook_set_current_page(GTK_NOTEBOOK(prefswindow->notebook), pagenum); adj = gtk_scrolled_window_get_vadjustment( GTK_SCROLLED_WINDOW(page->widget)); lower = gtk_adjustment_get_lower(adj); gtk_adjustment_set_value(adj, lower); gtk_adjustment_changed(adj); adj = gtk_scrolled_window_get_hadjustment( GTK_SCROLLED_WINDOW(page->widget)); gtk_adjustment_set_value(adj, lower); gtk_adjustment_changed(adj); #ifdef GENERIC_UMPC prefs_show_page(prefswindow); #endif return TRUE; }