static void codec_moved_cb (GtkWidget *widget, gpointer data) { CodecsBox *self = NULL; GtkTreeIter iter; GtkTreeIter *iter2 = NULL; GtkTreeModel *model = NULL; GtkTreeSelection *selection = NULL; GtkTreePath *tree_path = NULL; std::list<std::string> list; gchar *path_str = NULL; self = CODECS_BOX (data); model = gtk_tree_view_get_model (GTK_TREE_VIEW (self->priv->codecs_list)); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self->priv->codecs_list)); if (!gtk_tree_selection_get_selected (GTK_TREE_SELECTION (selection), NULL, &iter)) return; /* Update the tree view */ iter2 = gtk_tree_iter_copy (&iter); path_str = gtk_tree_model_get_string_from_iter (GTK_TREE_MODEL (model), &iter); tree_path = gtk_tree_path_new_from_string (path_str); if (!g_strcmp0 ((gchar *) g_object_get_data (G_OBJECT (widget), "operation"), "up")) gtk_tree_path_prev (tree_path); else gtk_tree_path_next (tree_path); gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter, tree_path); if (gtk_list_store_iter_is_valid (GTK_LIST_STORE (model), &iter) && gtk_list_store_iter_is_valid (GTK_LIST_STORE (model), iter2)) gtk_list_store_swap (GTK_LIST_STORE (model), &iter, iter2); /* Scroll to the new position */ gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (self->priv->codecs_list), tree_path, NULL, FALSE, 0, 0); gtk_tree_path_free (tree_path); gtk_tree_iter_free (iter2); g_free (path_str); /* Update the key */ list = codecs_box_to_list (self); if (self->priv->type == Ekiga::Call::Audio) self->priv->audio_settings->set_string_list ("media-list", list); else if (self->priv->type == Ekiga::Call::Video) self->priv->video_settings->set_string_list ("media-list", list); }
unsigned int wxComboBox::GetCount() const { wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid combobox") ); #ifdef __WXGTK24__ if (!gtk_check_version(2,4,0)) { GtkComboBox* combobox = GTK_COMBO_BOX( m_widget ); GtkTreeModel* model = gtk_combo_box_get_model( combobox ); GtkTreeIter iter; gtk_tree_model_get_iter_first( model, &iter ); if (!gtk_list_store_iter_is_valid(GTK_LIST_STORE(model), &iter )) return 0; unsigned int ret = 1; while (gtk_tree_model_iter_next( model, &iter )) ret++; return ret; } else #endif { GtkWidget *list = GTK_COMBO(m_widget)->list; GList *child = GTK_LIST(list)->children; unsigned int count = 0; while (child) { count++; child = child->next; } return count; } return 0; }
static void clue_check_isempty (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, UIData *ui) { GtkTreeSelection *selection; gchar *keyword = NULL; gboolean valid; selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (ui->treeview)); /* move to the previous node */ valid = gtk_tree_path_prev (path); gtk_tree_model_get (model, iter, CLUE_KEYWORD_COLUMN, &keyword, -1); if ((keyword) && !(g_utf8_strlen (g_strstrip (keyword), -1) > 0)) gtk_list_store_remove (ui->store, iter); /* Check if we have a valid row to select. If not, then select * the previous row */ if (gtk_list_store_iter_is_valid (GTK_LIST_STORE (model), iter)) { gtk_tree_selection_select_iter (selection, iter); } else { if (path && valid) { gtk_tree_model_get_iter (model, iter, path); gtk_tree_selection_select_iter (selection, iter); } } gtk_widget_grab_focus (ui->treeview); g_free (keyword); }
int wxChoice::FindString( const wxString &item, bool bCase ) const { wxCHECK_MSG( m_widget != NULL, wxNOT_FOUND, wxT("invalid control") ); GtkComboBox* combobox = GTK_COMBO_BOX( m_widget ); GtkTreeModel* model = gtk_combo_box_get_model( combobox ); GtkTreeIter iter; gtk_tree_model_get_iter_first( model, &iter ); if (!gtk_list_store_iter_is_valid(GTK_LIST_STORE(model), &iter )) return -1; int count = 0; do { GValue value = G_VALUE_INIT; gtk_tree_model_get_value( model, &iter, m_stringCellIndex, &value ); wxString str = wxGTK_CONV_BACK( g_value_get_string( &value ) ); g_value_unset( &value ); if (item.IsSameAs( str, bCase ) ) return count; count++; } while ( gtk_tree_model_iter_next(model, &iter) ); return wxNOT_FOUND; }
gboolean gnc_tree_model_budget_get_iter_for_budget(GtkTreeModel *tm, GtkTreeIter *iter, GncBudget *bgt) { GValue gv = { 0 }; const GncGUID *guid1; GncGUID *guid2; g_return_val_if_fail(GNC_BUDGET(bgt), FALSE); guid1 = gnc_budget_get_guid(bgt); if (!gtk_tree_model_get_iter_first(tm, iter)) return FALSE; while (gtk_list_store_iter_is_valid(GTK_LIST_STORE(tm), iter)) { gtk_tree_model_get_value(tm, iter, BUDGET_GUID_COLUMN, &gv); guid2 = (GncGUID *) g_value_get_pointer(&gv); g_value_unset(&gv); if (guid_equal(guid1, guid2)) return TRUE; if (!gtk_tree_model_iter_next(tm, iter)) return FALSE; } return FALSE; }
/* Update combo if property in channel changes */ static void power_manager_plugin_panel_label_changed (XfconfChannel *channel, const gchar *property, const GValue *value, gpointer user_data) { GtkWidget *combo = user_data; GtkListStore *list_store; GtkTreeIter iter; int show_panel_label, current_setting; list_store = GTK_LIST_STORE (gtk_combo_box_get_model (GTK_COMBO_BOX (combo))); current_setting = g_value_get_int (value); /* If the value set in xfconf is invalid, treat it like 0 aka "None" */ if (current_setting < 0 || current_setting > 3) current_setting = 0; for (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter); gtk_list_store_iter_is_valid (list_store, &iter); gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter)) { gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter, 0, &show_panel_label, -1); if (show_panel_label == current_setting) gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combo), &iter); } }
static void _code_assist_tree_selection_changed (GtkTreeSelection *selection, gpointer data) { CodeAssistWidget *code_assist_widget = (CodeAssistWidget *)data; GtkTreeIter tree_iter; gtk_tree_selection_get_selected (selection, NULL, &tree_iter); if (!gtk_list_store_iter_is_valid (code_assist_widget->list_store, &tree_iter)) return; gpointer value; gtk_tree_model_get (GTK_TREE_MODEL (code_assist_widget->list_store), &tree_iter, ASSIST_COL_POINTER, &value, -1); PyVariable *py_var = PY_VARIABLE (value); if (!py_var) return; if (py_var->doc_string) { if (!gtk_widget_get_parent (code_assist_widget->text_scroll_win)) gtk_box_pack_start (GTK_BOX (code_assist_widget->parent), code_assist_widget->text_scroll_win, FALSE, FALSE, 0); gtk_widget_show_all (code_assist_widget->text_scroll_win); GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (code_assist_widget->text_view)); gtk_text_buffer_set_text (buffer, py_var->doc_string, -1); } else { if (gtk_widget_get_parent (code_assist_widget->text_scroll_win)) gtk_container_remove (GTK_CONTAINER (code_assist_widget->parent), code_assist_widget->text_scroll_win); } }
gboolean code_assist_show_matches (CodeAssistWidget *code_assist, gchar *string) { GtkTreeIter tree_iter; gtk_list_store_clear (code_assist->list_store); gboolean found = FALSE; int i; for (i = 0; i < code_assist->py_var_array_size; i++) { if (g_strstr_len (code_assist->py_var_array [i]->name, -1, string)) { _code_assist_show_py_var (code_assist, code_assist->py_var_array [i]); found = TRUE; } } if (!found) return FALSE; GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (code_assist->list_view)); gtk_tree_model_get_iter_first (GTK_TREE_MODEL (code_assist->list_store), &tree_iter); if (!gtk_list_store_iter_is_valid (code_assist->list_store, &tree_iter)) return FALSE; //gtk_widget_grab_focus (codewidget->code_assist_widget->list_view); gtk_tree_selection_select_iter (selection, &tree_iter); return TRUE; }
void on_show_system_colors_activate (GtkMenuItem *menuitem, gpointer user_data) { if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (menuitem))) { /* re-add the system colors */ add_rgb_file (get_system_file (), SYSTEM_COLOR); } else { /* hide the system colors. unfortunately we have to remove them since there's no way to simply hide them. */ gchar *type; GtkTreeIter iterator; GtkTreeView *treeview = GTK_TREE_VIEW (lookup_widget (gcolor2, "treeview")); GtkTreeModel *model = gtk_tree_view_get_model (treeview); gtk_tree_model_get_iter_first (model, &iterator); while (gtk_list_store_iter_is_valid (GTK_LIST_STORE (model), &iterator)) { gtk_tree_model_get (model, &iterator, COLOR_TYPE, &type, -1); if (!strcmp (type, SYSTEM_COLOR)) { gtk_list_store_remove (GTK_LIST_STORE (model), &iterator); } else { gtk_tree_model_iter_next (model, &iterator); } } } }
/** * Move account in list depending on direction and selected account */ static void account_move(gboolean move_up, gpointer data) { // Get view, model and selection of account GtkTreeView *tree_view = GTK_TREE_VIEW(data); GtkTreeModel *model = gtk_tree_view_get_model(tree_view); GtkTreeSelection *selection = gtk_tree_view_get_selection(tree_view); // Find selected iteration and create a copy GtkTreeIter iter; gtk_tree_selection_get_selected(selection, &model, &iter); GtkTreeIter *iter_copy; iter_copy = gtk_tree_iter_copy(&iter); // Find path of iteration gchar *path = gtk_tree_model_get_string_from_iter(model, &iter); // The first real account in the list can't move up because of the IP2IP account // It can still move down though if (g_strcmp0(path, "1") == 0 && move_up) return; GtkTreePath *tree_path = gtk_tree_path_new_from_string(path); gint *indices = gtk_tree_path_get_indices(tree_path); const gint pos = indices[0] - 1; /* black magic : gtk tree order is not account queue order */ // Depending on button direction get new path if (move_up) gtk_tree_path_prev(tree_path); else gtk_tree_path_next(tree_path); gtk_tree_model_get_iter(model, &iter, tree_path); // Swap iterations if valid if (gtk_list_store_iter_is_valid(GTK_LIST_STORE(model), &iter)) gtk_list_store_swap(GTK_LIST_STORE(model), &iter, iter_copy); // Scroll to new position gtk_tree_view_scroll_to_cell(tree_view, tree_path, NULL, FALSE, 0, 0); // Free resources gtk_tree_path_free(tree_path); gtk_tree_iter_free(iter_copy); g_free(path); // Perpetuate changes in account queue if (move_up) account_list_move_up(pos); else account_list_move_down(pos); // Set the order in the configuration file gchar *ordered_account_list = account_list_get_ordered_list(); dbus_set_accounts_order(ordered_account_list); g_free(ordered_account_list); }
static void tb_editor_drag_data_rcvd_cb(GtkWidget *widget, GdkDragContext *context, gint x, gint y, GtkSelectionData *data, guint info, guint ltime, TBEditorWidget *tbw) { GtkTreeView *tree = GTK_TREE_VIEW(widget); gboolean del = FALSE; if (gtk_selection_data_get_target (data) != GDK_NONE ) { gboolean is_sep; const guchar *text = gtk_selection_data_get_data (data); is_sep = (g_strcmp0(text, "Separator") == 0); /* If the source of the action is equal to the target, we do just re-order and ** so need to delete the separator to get it moved, not just copied. */ if (is_sep && widget == tbw->drag_source) is_sep = FALSE; if (tree != tbw->tree_available || ! is_sep) { GtkTreeIter iter, iter_before, *iter_before_ptr; GtkListStore *store = GTK_LIST_STORE(gtk_tree_view_get_model(tree)); if (tbw->last_drag_path != NULL) { gtk_tree_model_get_iter(GTK_TREE_MODEL(store), &iter_before, tbw->last_drag_path); if (gtk_list_store_iter_is_valid(store, &iter_before)) iter_before_ptr = &iter_before; else iter_before_ptr = NULL; if (tbw->last_drag_pos == GTK_TREE_VIEW_DROP_BEFORE || tbw->last_drag_pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE) gtk_list_store_insert_before(store, &iter, iter_before_ptr); else gtk_list_store_insert_after(store, &iter, iter_before_ptr); tb_editor_set_item_values(tbw, text, store, &iter); } else { gtk_list_store_append(store, &iter); tb_editor_set_item_values(tbw, text, store, &iter); } tb_editor_scroll_to_iter(tree, &iter); } if (tree != tbw->tree_used || ! is_sep) del = TRUE; } tbw->drag_source = NULL; /* reset the value just to be sure */ tb_editor_free_path(tbw); gtk_drag_finish(context, TRUE, del, ltime); }
/* Eine Telefonliste soll gespeichert werden */ void saveButtonClicked(GtkWidget *widget, GdkEvent *event, gpointer data){ GtkTreeIter iter; char* name; if(gtk_tree_selection_get_selected (listsListSel, NULL, &iter)){ if(gtk_list_store_iter_is_valid(listsListStore, &iter)){ gtk_tree_model_get((GtkTreeModel*)listsListStore, &iter, NAME_LISTS_COLUMN, &name, -1); savePhoneList(name); } } }
static void eds_ok_button_clicked (GtkButton *button, PlannerPlugin *plugin) { GtkTreeIter iter; PlannerPluginPriv *priv = plugin->priv; GList *resources_orig; /* We are going to modify the resources. Work with a copy */ resources_orig = mrp_project_get_resources (plugin->priv->project); if (!priv->resources_model) { eds_dialog_close (plugin); return; } gtk_tree_model_get_iter_first (priv->resources_model, &iter); if (!gtk_list_store_iter_is_valid (GTK_LIST_STORE (priv->resources_model), &iter)) { eds_dialog_close (plugin); return; } /* Custom property for e-d-s resource UID */ if (!mrp_project_has_property (plugin->priv->project, MRP_TYPE_RESOURCE, "eds-uid")) { eds_create_uid_property (plugin); } do { EContact *contact; gboolean selected; gtk_tree_model_get (priv->resources_model, &iter, COL_RESOURCE_SELECTED, &selected, COL_RESOURCE_OBJECT, &contact, -1); if (selected) { gchar *name = e_contact_get (contact, E_CONTACT_FULL_NAME); gchar *email = e_contact_get (contact, E_CONTACT_EMAIL_1); gchar *eds_uid = e_contact_get (contact, E_CONTACT_UID); eds_import_resource (name, email, eds_uid, plugin, resources_orig); g_free (name); g_free (email); g_free (eds_uid); } } while (gtk_tree_model_iter_next (priv->resources_model, &iter)); eds_dialog_close (plugin); }
int wxComboBox::FindString( const wxString &item, bool bCase ) const { wxCHECK_MSG( m_widget != NULL, wxNOT_FOUND, wxT("invalid combobox") ); #ifdef __WXGTK24__ if (!gtk_check_version(2,4,0)) { GtkComboBox* combobox = GTK_COMBO_BOX( m_widget ); GtkTreeModel* model = gtk_combo_box_get_model( combobox ); GtkTreeIter iter; gtk_tree_model_get_iter_first( model, &iter ); if (!gtk_list_store_iter_is_valid(GTK_LIST_STORE(model), &iter )) return -1; int count = 0; do { GValue value = { 0, }; gtk_tree_model_get_value( model, &iter, 0, &value ); wxString str = wxGTK_CONV_BACK( g_value_get_string( &value ) ); g_value_unset( &value ); if (item.IsSameAs( str, bCase ) ) return count; count++; } while (gtk_tree_model_iter_next( model, &iter )); } else #endif { GtkWidget *list = GTK_COMBO(m_widget)->list; GList *child = GTK_LIST(list)->children; int count = 0; while (child) { GtkBin *bin = GTK_BIN( child->data ); GtkLabel *label = GTK_LABEL( bin->child ); wxString str( wxGTK_CONV_BACK( gtk_label_get_text(label) ) ); if (item.IsSameAs( str , bCase ) ) return count; count++; child = child->next; } } return wxNOT_FOUND; }
unsigned int wxChoice::GetCount() const { wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid control") ); GtkComboBox* combobox = GTK_COMBO_BOX( m_widget ); GtkTreeModel* model = gtk_combo_box_get_model( combobox ); GtkTreeIter iter; gtk_tree_model_get_iter_first( model, &iter ); if (!gtk_list_store_iter_is_valid(GTK_LIST_STORE(model), &iter )) return 0; unsigned int ret = 1; while (gtk_tree_model_iter_next( model, &iter )) ret++; return ret; }
/* Eine Telefonliste soll geschlossen werden */ void closeButtonClicked(GtkWidget *widget, GdkEvent *event, gpointer data){ GtkTreeIter iter; char* name; if(gtk_tree_selection_get_selected (listsListSel, NULL, &iter)){ if(gtk_list_store_iter_is_valid(listsListStore, &iter)){ gtk_tree_model_get((GtkTreeModel*)listsListStore, &iter, NAME_LISTS_COLUMN, &name, -1); closeListByName(name, &iter); if(gtk_tree_model_get_iter_first ((GtkTreeModel*)listsListStore, &iter)){ gtk_tree_selection_select_iter(listsListSel, &iter); } else { gtk_tree_view_set_model(GTK_TREE_VIEW(phoneView), GTK_TREE_MODEL(phoneDefaultStore)); } } } }
gboolean play(void *data) { PlayData *p = (PlayData *) data; if (ok_to_play && p != NULL) { if (!gtk_list_store_iter_is_valid(playliststore, &iter)) { // printf("iter is not valid, getting first one\n"); gtk_tree_model_get_iter_first(GTK_TREE_MODEL(playliststore), &iter); } gtk_list_store_set(playliststore, &iter, PLAYLIST_COLUMN, p->playlist, ITEM_COLUMN, p->uri, -1); play_iter(&iter, 0); } g_free(p); return FALSE; }
int clip_GTK_LISTSTOREITERISVALID(ClipMachine * cm) { C_object *cslist = _fetch_co_arg(cm); C_object *citer = _fetch_cobject(cm, _clip_spar(cm, 2)); CHECKARG2(1, MAP_t, NUMERIC_t); CHECKCOBJ(cslist, GTK_IS_LIST_STORE(cslist->object)); CHECKCOBJ(citer, GTK_IS_TREE_ITER(citer->object)); _clip_retl(cm, gtk_list_store_iter_is_valid(GTK_LIST_STORE(cslist->object), GTK_TREE_ITER(citer->object))); return 0; err: return 1; }
static void clue_remove_clicked (GtkButton *button, UIData *ui) { GtkTreeSelection *selection; GtkTreeModel *model; GtkTreeIter iter; GtkTreePath *path; gboolean valid; gint len; valid = FALSE; selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (ui->treeview)); if (!gtk_tree_selection_get_selected (selection, &model, &iter)) return; /* Get the path and move to the previous node :) */ path = gtk_tree_model_get_path (model, &iter); if (path) valid = gtk_tree_path_prev (path); gtk_list_store_remove (GTK_LIST_STORE (model), &iter); len = gtk_tree_model_iter_n_children (model, NULL); if (len > 0) { if (gtk_list_store_iter_is_valid (GTK_LIST_STORE (model), &iter)) { gtk_tree_selection_select_iter (selection, &iter); } else { if (path && valid) { gtk_tree_model_get_iter (model, &iter, path); gtk_tree_selection_select_iter (selection, &iter); } } } else { gtk_widget_set_sensitive (ui->clue_edit, FALSE); gtk_widget_set_sensitive (ui->clue_remove, FALSE); } gtk_widget_grab_focus (ui->treeview); gtk_tree_path_free (path); commit_changes (ui); }
void play_next() { gchar *filename; gint count; PlayData *p = NULL; if (next_item_in_playlist(&iter)) { if (gtk_list_store_iter_is_valid(playliststore, &iter)) { gtk_tree_model_get(GTK_TREE_MODEL(playliststore), &iter, ITEM_COLUMN, &filename, COUNT_COLUMN, &count, PLAYLIST_COLUMN, &playlist, -1); g_strlcpy(idledata->info, filename, 4096); g_idle_add(set_media_info, idledata); p = (PlayData *) g_malloc(sizeof(PlayData)); g_strlcpy(p->uri, filename, 4096); p->playlist = playlist; g_idle_add(play, p); g_free(filename); } } else { // printf("end of thread playlist is empty\n"); if (loop) { if (first_item_in_playlist(&iter)) { gtk_tree_model_get(GTK_TREE_MODEL(playliststore), &iter, ITEM_COLUMN, &filename, COUNT_COLUMN, &count, PLAYLIST_COLUMN, &playlist, -1); g_strlcpy(idledata->info, filename, 4096); g_idle_add(set_media_info, idledata); p = (PlayData *) g_malloc(sizeof(PlayData)); g_strlcpy(p->uri, filename, 4096); p->playlist = playlist; g_idle_add(play, p); g_free(filename); } } else { idledata->fullscreen = 0; g_idle_add(set_fullscreen, idledata); g_idle_add(set_stop, idledata); } if (quit_on_complete) { g_idle_add(set_quit, idledata); } } }
static gboolean clue_foreach_check_isempty (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, UIData *ui) { gboolean valid; valid = gtk_tree_model_get_iter_first (model, iter); while (valid && gtk_list_store_iter_is_valid (ui->store, iter)) { char *keyword = NULL; gtk_tree_model_get (model, iter, CLUE_KEYWORD_COLUMN, &keyword, -1); /* Check if the keyword is not empty and then emit the row-changed signal (if we delete the row, then the iter gets corrupted) */ if ((keyword) && !(g_utf8_strlen (g_strstrip (keyword), -1) > 0)) gtk_tree_model_row_changed (model, path, iter); g_free (keyword); valid = gtk_tree_model_iter_next (model, iter); } return FALSE; }
static void eds_import_change_all (PlannerPlugin *plugin, gboolean state) { GtkTreeIter iter; PlannerPluginPriv *priv = plugin->priv; gtk_tree_model_get_iter_first (priv->resources_model, &iter); if (!gtk_list_store_iter_is_valid (GTK_LIST_STORE (priv->resources_model), &iter)) { return; } do { gtk_list_store_set (GTK_LIST_STORE (priv->resources_model), &iter, COL_RESOURCE_SELECTED, state, -1); } while (gtk_tree_model_iter_next (priv->resources_model, &iter)); }
/* Laed ein neues Listenfile bzw. erzeugt * eine neue Liste. * Dazu wird ein Dateiauswahl-Dialog angezeigt, * dessen Ergebnis der Listenname ist. * Es wird auch ueberprueft ob die Datei bereits * geladen ist. * Args: * selectorTitle .. Der Titel der Dateiauswahl * existMsg .. Der Text der in dem Dialog * Angezeigt wird, der mitteilt, * das die Datei bereits geladen * ist und fragt ob sie neu geladen * werden soll. * type .. Legt Fest ob es ein "Oeffnen" Dialog * (zum oeffnen existierender Listen) * oder ein "Speichern" Dialog (zum * anlegen neuer Listen) sein soll. * Ret: * Nichts * */ void fetchNewListFile(char *selectorTitle, char *existMsg, int type){ GtkWidget *fileSel; char *filename; fileSel = gtk_file_chooser_dialog_new (selectorTitle, (GtkWindow*)main_app_window, type, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); if (gtk_dialog_run (GTK_DIALOG (fileSel)) == GTK_RESPONSE_ACCEPT){ filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fileSel)); if (getPhoneList(filename) == NULL){ if (type == GTK_FILE_CHOOSER_ACTION_SAVE){ newPhoneFile(filename); } if(pushPhoneList(readPhoneFile(filename), filename) == OK){ addPhoneModelList(filename); addListsListElm(filename); } } else { if(askYesNo(existMsg)){ closeListByName(filename, NULL); if(pushPhoneList(readPhoneFile(filename), filename) == OK){ addPhoneModelList(filename); addListsListElm(filename); } } } GtkTreeIter iter = getIterByFilename(filename); if(gtk_list_store_iter_is_valid(listsListStore, &iter)){ gtk_tree_selection_select_iter(listsListSel, &iter); } g_free (filename); } gtk_widget_destroy (fileSel); }
static void window_active_tab_changed (PlumaWindow *window, PlumaTab *tab, PlumaDocumentsPanel *panel) { g_return_if_fail (tab != NULL); if (!_pluma_window_is_removing_tabs (window)) { GtkTreeIter iter; GtkTreeSelection *selection; get_iter_from_tab (panel, tab, &iter); if (gtk_list_store_iter_is_valid (GTK_LIST_STORE (panel->priv->model), &iter)) { selection = gtk_tree_view_get_selection ( GTK_TREE_VIEW (panel->priv->treeview)); gtk_tree_selection_select_iter (selection, &iter); } } }
gboolean del_line(IMAGE *ima){ GtkTreeIter iter; GtkTreeModel *model = GTK_TREE_MODEL(ima->store); gboolean ret = FALSE; FNAME(); GtkTreeSelection *selection = gtk_tree_view_get_selection(Tree); GtkTreePath *path; if(gtk_tree_selection_get_selected(selection, NULL, &iter)){ path = gtk_tree_model_get_path(model, &iter); ret = gtk_list_store_remove(ima->store, &iter); // check wherher &cur_items was last if(gtk_list_store_iter_is_valid(ima->store, &iter)){ gtk_tree_path_free(path); path = gtk_tree_model_get_path(model, &iter); } else gtk_tree_path_prev(path); // goto previous if(path && gtk_tree_model_get_iter_first(model, &iter)) gtk_tree_view_set_cursor(Tree, path, NULL, FALSE); else DBG("No entries"); gtk_tree_path_free(path); } DBG("ret"); return ret; }
void on_trkproperties_crop_activate (GtkMenuItem *menuitem, gpointer user_data) { GtkTreeView *treeview = GTK_TREE_VIEW (lookup_widget (trackproperties, "metalist")); if (!gtk_widget_is_focus(GTK_WIDGET (treeview))) { return; // do not remove field if Metadata tab is not focused } GtkTreePath *path; gtk_tree_view_get_cursor (treeview, &path, NULL); if (!path) { return; } GtkTreeIter iter_curr; gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter_curr, path); GtkTreeModel *model = gtk_tree_view_get_model (treeview); GtkTreeIter iter; GtkTreeIter next; gboolean res = gtk_tree_model_get_iter_first (model, &iter); while (res) { int getnext = 1; GtkTreePath *iter_path = gtk_tree_model_get_path (model, &iter); if (gtk_tree_path_compare (path, iter_path)) { GValue key = {0,}; gtk_tree_model_get_value (model, &iter, 2, &key); const char *skey = g_value_get_string (&key); GValue value = {0,}; gtk_tree_model_get_value (GTK_TREE_MODEL (store), &iter, 2, &value); const char *svalue = g_value_get_string (&value); // delete unknown fields completely; otherwise just clear int i = 0; for (; trkproperties_types[i]; i += 2) { if (!strcasecmp (svalue, trkproperties_types[i])) { break; } } if (trkproperties_types[i]) { // known val, clear gtk_list_store_set (store, &iter, 1, "", 3, 0, 4, "", -1); } else { gtk_list_store_remove (store, &iter); getnext = 0; if (!gtk_list_store_iter_is_valid (GTK_LIST_STORE (model), &iter)) { res = 0; } } } gtk_tree_path_free (iter_path); if (getnext) { res = gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter); } } gtk_tree_view_set_cursor (treeview, path, NULL, FALSE); // restore cursor after deletion gtk_tree_path_free (path); trkproperties_modified = 1; }
/* Sets up the charsets to choose from in the "combo". It presets the charset stored in cfg->charset (or "System Charset" if none is set there */ void charset_init_combo_box (GtkComboBox *combo) { gchar *current_charset; gchar *description; const CharsetInfo *ci; GtkCellRenderer *renderer; GtkTreeIter use_iter; static GtkListStore *charsets = NULL; /* list with choices -- takes a while to * initialize, so we only do it once */ current_charset = prefs_get_string("charset"); if ((current_charset == NULL) || (strlen (current_charset) == 0)) { description = g_strdup (_("System Charset")); } else { description = charset_to_description (current_charset); } if (charsets == NULL) { /* set up list with charsets */ FILE *fp; GtkTreeIter iter; charsets = gtk_list_store_new (1, G_TYPE_STRING); /* now add all the charset descriptions in the list above */ gtk_list_store_append (charsets, &iter); gtk_list_store_set (charsets, &iter, 0, _("System Charset"), -1); for (ci = charset_info; ci->descr; ci++) { gtk_list_store_append (charsets, &iter); gtk_list_store_set (charsets, &iter, 0, _(ci->descr), -1); } /* let's add all available charsets returned by "iconv -l" */ /* The code assumes that "iconv -l" returns a list with the name of one charset in each line, each valid line being terminated by "//". */ fp = popen ("iconv -l", "r"); if (fp) { gchar buf[PATH_MAX]; /* read one line of output at a time */ while (fgets (buf, PATH_MAX, fp)) { /* only consider lines ending on "//" */ gchar *bufp = g_strrstr (buf, "//\n"); if (bufp) { /* add everything before "//" to our charset list */ gchar *bufpp = buf; *bufp = 0; /* shorten string */ while ((*bufpp == ' ') || (*bufpp == 0x09)) bufpp++; /* skip whitespace */ if (*bufpp) { gtk_list_store_append (charsets, &iter); gtk_list_store_set (charsets, &iter, 0, bufpp, -1); } } } pclose (fp); } } /* set pull down items */ renderer = gtk_cell_renderer_text_new (); gtk_combo_box_set_model (GTK_COMBO_BOX (combo), GTK_TREE_MODEL (charsets)); gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo)); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, FALSE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo), renderer, "text", 0); for (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (charsets), &use_iter); gtk_list_store_iter_is_valid (charsets, &use_iter); gtk_tree_model_iter_next (GTK_TREE_MODEL (charsets), &use_iter)) { gchar *cur_desc; gtk_tree_model_get (GTK_TREE_MODEL (charsets), &use_iter, 0, &cur_desc, -1); if(!g_utf8_collate(description, cur_desc)) { g_free (cur_desc); break; } g_free (cur_desc); } gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combo), &use_iter); g_free (description); g_free (current_charset); }
static VALUE rg_iter_is_valid_p(VALUE self, VALUE iter) { return (NIL_P(iter)) ? Qfalse : CBOOL2RVAL(gtk_list_store_iter_is_valid(_SELF(self), RVAL2GTKTREEITER(iter))); }
gint play_iter(GtkTreeIter * playiter, gint restart_second) { gchar *subtitle = NULL; gchar *audiofile = NULL; GtkTreePath *path; gchar *uri = NULL; gint count; gint playlist; gchar *title = NULL; gchar *artist = NULL; gchar *album = NULL; gchar *audio_codec; gchar *video_codec = NULL; GtkAllocation alloc; gchar *demuxer = NULL; gboolean playable = TRUE; gint width; gint height; gfloat length_value; gint i; gpointer pixbuf; gchar *buffer = NULL; gchar *message = NULL; MetaData *metadata; #ifdef GTK2_12_ENABLED GtkRecentData *recent_data; #ifdef GIO_ENABLED GFile *file; GFileInfo *file_info; #endif #endif /* if (!(gmtk_media_player_get_state(GMTK_MEDIA_PLAYER(media)) == MEDIA_STATE_UNKNOWN || gmtk_media_player_get_state(GMTK_MEDIA_PLAYER(media)) == MEDIA_STATE_QUIT)) { while (gmtk_media_player_get_state(GMTK_MEDIA_PLAYER(media)) != MEDIA_STATE_UNKNOWN) { gtk_main_iteration(); } } */ if (gtk_list_store_iter_is_valid(playliststore, playiter)) { gtk_tree_model_get(GTK_TREE_MODEL(playliststore), playiter, ITEM_COLUMN, &uri, DESCRIPTION_COLUMN, &title, LENGTH_VALUE_COLUMN, &length_value, ARTIST_COLUMN, &artist, ALBUM_COLUMN, &album, AUDIO_CODEC_COLUMN, &audio_codec, VIDEO_CODEC_COLUMN, &video_codec, VIDEO_WIDTH_COLUMN, &width, VIDEO_HEIGHT_COLUMN, &height, DEMUXER_COLUMN, &demuxer, COVERART_COLUMN, &pixbuf, SUBTITLE_COLUMN, &subtitle, AUDIOFILE_COLUMN, &audiofile, COUNT_COLUMN, &count, PLAYLIST_COLUMN, &playlist, PLAYABLE_COLUMN, &playable, -1); if (GTK_IS_TREE_SELECTION(selection)) { path = gtk_tree_model_get_path(GTK_TREE_MODEL(playliststore), playiter); if (path) { gtk_tree_selection_select_path(selection, path); if (GTK_IS_WIDGET(list)) gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(list), path, NULL, FALSE, 0, 0); buffer = gtk_tree_path_to_string(path); g_free(buffer); gtk_tree_path_free(path); } } gtk_list_store_set(playliststore, playiter, COUNT_COLUMN, count + 1, -1); } else { if (verbose > 1) printf("iter is invalid, nothing to play\n"); return 0; } if (verbose) { printf("playing - %s\n", uri); printf("is playlist %i\n", playlist); } gmtk_get_allocation(GTK_WIDGET(media), &alloc); if (width == 0 || height == 0) { alloc.width = 16; alloc.height = 16; } else { alloc.width = width; alloc.height = height; } //printf("setting window size to %i x %i\n", alloc.width, alloc.height); gtk_widget_size_allocate(GTK_WIDGET(media), &alloc); while (gtk_events_pending()) gtk_main_iteration(); /* // wait for metadata to be available on this item if (!streaming_media(uri) && !device_name(uri)) { i = 0; if (playable) { while (demuxer == NULL && i < 50) { g_free(title); g_free(artist); g_free(album); g_free(audio_codec); g_free(video_codec); g_free(demuxer); g_free(subtitle); g_free(audiofile); if (gtk_list_store_iter_is_valid(playliststore, playiter)) { gtk_tree_model_get(GTK_TREE_MODEL(playliststore), playiter, LENGTH_VALUE_COLUMN, &length_value, DESCRIPTION_COLUMN, &title, ARTIST_COLUMN, &artist, ALBUM_COLUMN, &album, AUDIO_CODEC_COLUMN, &audio_codec, VIDEO_CODEC_COLUMN, &video_codec, VIDEO_WIDTH_COLUMN, &width, VIDEO_HEIGHT_COLUMN, &height, DEMUXER_COLUMN, &demuxer, COVERART_COLUMN, &pixbuf, SUBTITLE_COLUMN, &subtitle, AUDIOFILE_COLUMN, &audiofile, COUNT_COLUMN, &count, PLAYLIST_COLUMN, &playlist, PLAYABLE_COLUMN, &playable, -1); if (!playable) { if (verbose) printf("%s is not marked as playable (%i)\n", uri, i); play_next(); return 0; } } else { if (verbose) printf("Current iter is not valid\n"); return 1; // error condition } gtk_main_iteration(); i++; if (demuxer == NULL) g_usleep(10000); } } else { if (verbose) printf("%s is not marked as playable\n", uri); play_next(); return 0; } } */ // reset audio meter for (i = 0; i < METER_BARS; i++) { buckets[i] = 0; max_buckets[i] = 0; } gmtk_media_tracker_set_text(tracker, _("Playing")); gmtk_media_tracker_set_position(tracker, (gfloat) restart_second); gmtk_media_tracker_set_length(tracker, length_value); message = g_strdup_printf("<small>\n"); if (title == NULL) { title = g_filename_display_basename(uri); } buffer = g_markup_printf_escaped("\t<big><b>%s</b></big>\n", title); message = g_strconcat(message, buffer, NULL); g_free(buffer); if (artist != NULL) { buffer = g_markup_printf_escaped("\t<i>%s</i>\n", artist); message = g_strconcat(message, buffer, NULL); g_free(buffer); } if (album != NULL) { buffer = g_markup_printf_escaped("\t%s\n", album); message = g_strconcat(message, buffer, NULL); g_free(buffer); } //buffer = g_markup_printf_escaped("\n\t%s\n", uri); //message = g_strconcat(message, buffer, NULL); //g_free(buffer); message = g_strconcat(message, "</small>", NULL); // probably not much cover art for random video files if (pixbuf == NULL && video_codec == NULL && !streaming_media(uri) && control_id == 0 && !playlist) { metadata = (MetaData *) g_new0(MetaData, 1); metadata->uri = g_strdup(uri); if (title != NULL) metadata->title = g_strstrip(g_strdup(title)); if (artist != NULL) metadata->artist = g_strstrip(g_strdup(artist)); if (album != NULL) metadata->album = g_strstrip(g_strdup(album)); g_thread_create(get_cover_art, metadata, FALSE, NULL); } else { gtk_image_clear(GTK_IMAGE(cover_art)); } g_strlcpy(idledata->media_info, message, 1024); g_strlcpy(idledata->display_name, title, 1024); g_free(message); message = gm_tempname(NULL, "mplayer-af_exportXXXXXX"); g_strlcpy(idledata->af_export, message, 1024); g_free(message); message = g_strdup(""); if (title == NULL) { title = g_filename_display_basename(uri); } //buffer = g_markup_printf_escaped("\t<b>%s</b>\n", title); //message = g_strconcat(message, buffer, NULL); //g_free(buffer); if (artist != NULL) { buffer = g_markup_printf_escaped("\t<i>%s</i>\n", artist); message = g_strconcat(message, buffer, NULL); g_free(buffer); } if (album != NULL) { buffer = g_markup_printf_escaped("\t%s\n", album); message = g_strconcat(message, buffer, NULL); g_free(buffer); } g_strlcpy(idledata->media_notification, message, 1024); g_free(message); if (control_id == 0) { set_media_label(idledata); } else { gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem_view_info), FALSE); } if (subtitles) gtk_container_forall(GTK_CONTAINER(subtitles), remove_langs, NULL); gtk_widget_set_sensitive(GTK_WIDGET(menuitem_edit_select_sub_lang), FALSE); if (tracks) gtk_container_forall(GTK_CONTAINER(tracks), remove_langs, NULL); gtk_widget_set_sensitive(GTK_WIDGET(menuitem_edit_select_audio_lang), FALSE); lang_group = NULL; audio_group = NULL; if (subtitle != NULL) { gmtk_media_player_set_attribute_string(GMTK_MEDIA_PLAYER(media), ATTRIBUTE_SUBTITLE_FILE, subtitle); g_free(subtitle); subtitle = NULL; } if (audiofile != NULL) { gmtk_media_player_set_attribute_string(GMTK_MEDIA_PLAYER(media), ATTRIBUTE_AUDIO_TRACK_FILE, audiofile); g_free(audiofile); audiofile = NULL; } /* if (g_ascii_strcasecmp(thread_data->filename, "") != 0) { if (!device_name(thread_data->filename) && !streaming_media(thread_data->filename)) { if (!g_file_test(thread_data->filename, G_FILE_TEST_EXISTS)) { error_msg = g_strdup_printf("%s not found\n", thread_data->filename); dialog = gtk_message_dialog_new(NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "%s", error_msg); gtk_window_set_title(GTK_WINDOW(dialog), "GNOME MPlayer Error"); gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog); return 1; } } } */ #ifdef GTK2_12_ENABLED #ifdef GIO_ENABLED // don't put it on the recent list, if it is running in plugin mode if (control_id == 0 && !streaming_media(uri)) { recent_data = (GtkRecentData *) g_new0(GtkRecentData, 1); if (artist != NULL && strlen(artist) > 0) { recent_data->display_name = g_strdup_printf("%s - %s", artist, title); } else { recent_data->display_name = g_strdup(title); } g_strlcpy(idledata->display_name, recent_data->display_name, 1024); file = g_file_new_for_uri(uri); file_info = g_file_query_info(file, G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE "," G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME, G_FILE_QUERY_INFO_NONE, NULL, NULL); if (file_info) { recent_data->mime_type = g_strdup(g_file_info_get_content_type(file_info)); g_object_unref(file_info); } g_object_unref(file); recent_data->app_name = g_strdup("gnome-mplayer"); recent_data->app_exec = g_strdup("gnome-mplayer %u"); if (recent_data->mime_type != NULL) { gtk_recent_manager_add_full(recent_manager, uri, recent_data); g_free(recent_data->mime_type); } g_free(recent_data->app_name); g_free(recent_data->app_exec); g_free(recent_data); } #endif #endif g_free(title); g_free(artist); g_free(album); if (demuxer != NULL) { g_strlcpy(idledata->demuxer, demuxer, 64); g_free(demuxer); } else { g_strlcpy(idledata->demuxer, "", 64); } last_x = 0; last_y = 0; idledata->width = width; idledata->height = height; idledata->retry_on_full_cache = FALSE; idledata->cachepercent = -1.0; g_strlcpy(idledata->info, uri, 1024); set_media_info(idledata); streaming = 0; gm_store = gm_pref_store_new("gnome-mplayer"); forcecache = gm_pref_store_get_boolean(gm_store, FORCECACHE); gm_pref_store_free(gm_store); if (g_ascii_strcasecmp(uri, "dvdnav://") == 0) { gtk_widget_show(menu_event_box); } else { gtk_widget_hide(menu_event_box); } if (autostart) { g_idle_add(hide_buttons, idledata); js_state = STATE_PLAYING; if (g_str_has_prefix(uri, "mmshttp") || g_str_has_prefix(uri, "http") || g_str_has_prefix(uri, "mms")) { gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_NETWORK); } else if (g_str_has_prefix(uri, "dvd") || g_str_has_prefix(uri, "dvdnav")) { gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_DVD); } else if (g_str_has_prefix(uri, "cdda")) { gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_CD); } else if (g_str_has_prefix(uri, "cddb")) { gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_CD); } else if (g_str_has_prefix(uri, "vcd")) { gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_VCD); } else if (g_str_has_prefix(uri, "tv")) { gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_TV); } else if (g_str_has_prefix(uri, "dvb")) { gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_DVB); } else if (g_str_has_prefix(uri, "file")) { gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_FILE); } else { // if all else fails it must be a network type gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_NETWORK); } gmtk_media_player_set_attribute_boolean(GMTK_MEDIA_PLAYER(media), ATTRIBUTE_PLAYLIST, playlist); gmtk_media_player_set_uri(GMTK_MEDIA_PLAYER(media), uri); gmtk_media_player_set_state(GMTK_MEDIA_PLAYER(media), MEDIA_STATE_PLAY); } return 0; }
static void window_tab_added (PlumaWindow *window, PlumaTab *tab, PlumaDocumentsPanel *panel) { GtkTreeIter iter; GtkTreeIter sibling; GdkPixbuf *pixbuf; gchar *name; g_signal_connect (tab, "notify::name", G_CALLBACK (sync_name_and_icon), panel); g_signal_connect (tab, "notify::state", G_CALLBACK (sync_name_and_icon), panel); get_iter_from_tab (panel, tab, &sibling); panel->priv->adding_tab = TRUE; if (gtk_list_store_iter_is_valid (GTK_LIST_STORE (panel->priv->model), &sibling)) { gtk_list_store_insert_after (GTK_LIST_STORE (panel->priv->model), &iter, &sibling); } else { PlumaTab *active_tab; gtk_list_store_append (GTK_LIST_STORE (panel->priv->model), &iter); active_tab = pluma_window_get_active_tab (panel->priv->window); if (tab == active_tab) { GtkTreeSelection *selection; selection = gtk_tree_view_get_selection ( GTK_TREE_VIEW (panel->priv->treeview)); gtk_tree_selection_select_iter (selection, &iter); } } name = tab_get_name (tab); pixbuf = _pluma_tab_get_icon (tab); gtk_list_store_set (GTK_LIST_STORE (panel->priv->model), &iter, PIXBUF_COLUMN, pixbuf, NAME_COLUMN, name, TAB_COLUMN, tab, -1); g_free (name); if (pixbuf != NULL) g_object_unref (pixbuf); panel->priv->adding_tab = FALSE; }