// This callback is responsible for enabling/disabling the appropriate buttons depending on // the contents of the selection static void tree_view_selection_changed (GtkTreeSelection *sel, gpointer data) { bus_layout_D *dialog = (bus_layout_D *)data ; gboolean bSomethingSelected = FALSE ; gboolean bBusSelected = FALSE ; gboolean bSelectionIsFromBus = FALSE ; gboolean bFirstSelected = FALSE ; gboolean bLastSelected = FALSE ; gboolean bFirstBusSelected = TRUE ; gboolean bLastBusSelected = TRUE ; GtkTreePath *tpSelBus = NULL, *tp = NULL ; GtkTreeModel *tm = NULL ; int icChildren = -1, Nix ; tm = gtk_tree_view_get_model (gtk_tree_selection_get_tree_view (sel)) ; if ((bSelectionIsFromBus = (NULL != (tpSelBus = get_selection_bus (sel, &bSomethingSelected))))) if (!(bFirstSelected = bLastSelected = bBusSelected = whole_bus_selected_p (sel, tm, tpSelBus))) if ((icChildren = gtk_tree_model_path_n_children (tm, tpSelBus)) > 0) { gtk_tree_path_down (tp = gtk_tree_path_copy (tpSelBus)) ; bFirstSelected = gtk_tree_selection_path_is_selected (sel, tp) ; for (Nix = 1 ; Nix < icChildren ; Nix++) gtk_tree_path_next (tp) ; bLastSelected = gtk_tree_selection_path_is_selected (sel, tp) ; gtk_tree_path_free (tp) ; } if (bSelectionIsFromBus) determine_first_or_last_bus (tm, tpSelBus, &bFirstBusSelected, &bLastBusSelected) ; gtk_widget_set_sensitive (dialog->btnCreateBus, bSomethingSelected && !bBusSelected) ; gtk_widget_set_sensitive (dialog->btnDeleteBus, bSelectionIsFromBus) ; gtk_widget_set_sensitive (dialog->btnMoveBusUp, bSelectionIsFromBus && !bFirstBusSelected) ; gtk_widget_set_sensitive (dialog->btnMoveBusDown, bSelectionIsFromBus && !bLastBusSelected) ; gtk_widget_set_sensitive (dialog->btnMoveCellsUp, bSelectionIsFromBus && !bFirstSelected) ; gtk_widget_set_sensitive (dialog->btnMoveCellsDown, bSelectionIsFromBus && !bLastSelected) ; gtk_widget_set_sensitive (dialog->lblBusName, bSelectionIsFromBus) ; gtk_widget_set_sensitive (dialog->txtBusName, bSelectionIsFromBus) ; // Fill in the text box with the name of the bus if (bSelectionIsFromBus) { GtkTreeIter itr ; char *psz = NULL ; gtk_tree_model_get_iter (tm, &itr, tpSelBus) ; gtk_tree_model_get (tm, &itr, BUS_LAYOUT_MODEL_COLUMN_NAME, &psz, -1) ; g_signal_handlers_block_matched (G_OBJECT (dialog->txtBusName), G_SIGNAL_MATCH_FUNC, 0, 0, NULL, (gpointer)bus_name_changed, NULL) ; gtk_entry_set_text (GTK_ENTRY (dialog->txtBusName), psz) ; g_signal_handlers_unblock_matched (G_OBJECT (dialog->txtBusName), G_SIGNAL_MATCH_FUNC, 0, 0, NULL, (gpointer)bus_name_changed, NULL) ; g_free (psz) ; } if (NULL != (tp = g_object_get_data (G_OBJECT (gtk_tree_selection_get_tree_view (sel)), "tpBus"))) gtk_tree_path_free (tp) ; g_object_set_data (G_OBJECT (gtk_tree_selection_get_tree_view (sel)), "tpBus", tpSelBus) ; }
static gboolean cm_try_to_select(CMPathWalkFunc path_func, GtkTreeSelection *selection, GtkTreeModel *model, GtkTreePath *path) { GtkTreeIter iter; if (gtk_tree_path_get_depth(path) <= 0) /* sanity check */ return FALSE; /* modify the path using the passed function */ if (path_func != NULL) path_func(path); if (gtk_tree_path_get_depth(path) <= 0) /* sanity check */ return FALSE; /* check whether the path points to something valid and if so, select it */ if (gtk_tree_model_get_iter(model, &iter, path)) { GtkTreeView *treeview = gtk_tree_selection_get_tree_view(selection); gboolean was_expanded = gtk_tree_view_row_expanded(treeview, path); /* to get gtk_tree_selection_select_path() working, we need to expand the row first * if it isn't expanded yet, at least when the row is a parent item */ if (! was_expanded) gtk_tree_view_expand_to_path(treeview, path); gtk_tree_selection_select_path(selection, path); if (! was_expanded) /* restore the previous state */ gtk_tree_view_collapse_row(treeview, path); return TRUE; } return FALSE; }
static void selection_changed (GtkTreeSelection *selection) { GtkTreeView *treeview; StockItemDisplay *display; GtkTreeModel *model; GtkTreeIter iter; treeview = gtk_tree_selection_get_tree_view (selection); display = g_object_get_data (G_OBJECT (treeview), "stock-display"); if (gtk_tree_selection_get_selected (selection, &model, &iter)) { StockItemInfo *info; gchar *str; gtk_tree_model_get (model, &iter, 0, &info, -1); if (info->small_icon && info->item.label) gtk_label_set_text (GTK_LABEL (display->type_label), "Icon and Item"); else if (info->small_icon) gtk_label_set_text (GTK_LABEL (display->type_label), "Icon Only"); else if (info->item.label) gtk_label_set_text (GTK_LABEL (display->type_label), "Item Only"); else gtk_label_set_text (GTK_LABEL (display->type_label), "???????"); gtk_label_set_text (GTK_LABEL (display->macro_label), info->macro); gtk_label_set_text (GTK_LABEL (display->id_label), info->id); if (info->item.label) { str = g_strdup_printf ("%s %s", info->item.label, info->accel_str); gtk_label_set_text_with_mnemonic (GTK_LABEL (display->label_accel_label), str); g_free (str); } else { gtk_label_set_text (GTK_LABEL (display->label_accel_label), ""); } if (info->small_icon) gtk_image_set_from_stock (GTK_IMAGE (display->icon_image), info->id, get_largest_size (info->id)); else gtk_image_set_from_pixbuf (GTK_IMAGE (display->icon_image), NULL); stock_item_info_free (info); } else { gtk_label_set_text (GTK_LABEL (display->type_label), "No selected item"); gtk_label_set_text (GTK_LABEL (display->macro_label), ""); gtk_label_set_text (GTK_LABEL (display->id_label), ""); gtk_label_set_text (GTK_LABEL (display->label_accel_label), ""); gtk_image_set_from_pixbuf (GTK_IMAGE (display->icon_image), NULL); } }
G_MODULE_EXPORT void queue_list_selection_changed_cb(GtkTreeSelection *selection, signal_user_data_t *ud) { GtkTreeModel *store; GtkTreeIter iter, piter; g_debug("queue_list_selection_changed_cb ()"); // A queue entry is made up of a parent and multiple // children that are visible when expanded. When and entry // is selected, I want the parent to be selected. // This is purely cosmetic. if (gtk_tree_selection_get_selected(selection, &store, &iter)) { GtkWidget *widget = GHB_WIDGET (ud->builder, "queue_edit"); gtk_widget_set_sensitive (widget, TRUE); if (gtk_tree_model_iter_parent (store, &piter, &iter)) { GtkTreePath *path; GtkTreeView *treeview; gtk_tree_selection_select_iter (selection, &piter); path = gtk_tree_model_get_path (store, &piter); treeview = gtk_tree_selection_get_tree_view (selection); // Make the parent visible in scroll window if it is not. gtk_tree_view_scroll_to_cell (treeview, path, NULL, FALSE, 0, 0); gtk_tree_path_free(path); } } else { GtkWidget *widget = GHB_WIDGET (ud->builder, "queue_edit"); gtk_widget_set_sensitive (widget, FALSE); } }
static void gnc_plugin_page_owner_tree_selection_changed_cb (GtkTreeSelection *selection, GncPluginPageOwnerTree *page) { GtkActionGroup *action_group; GtkTreeView *view; GncOwner *owner = NULL; gboolean sensitive; gboolean is_readwrite = !qof_book_is_readonly(gnc_get_current_book()); g_return_if_fail(GNC_IS_PLUGIN_PAGE_OWNER_TREE(page)); if (!selection) { sensitive = FALSE; } else { g_return_if_fail(GTK_IS_TREE_SELECTION(selection)); view = gtk_tree_selection_get_tree_view (selection); owner = gnc_tree_view_owner_get_selected_owner (GNC_TREE_VIEW_OWNER(view)); sensitive = (owner != NULL); } action_group = gnc_plugin_page_get_action_group(GNC_PLUGIN_PAGE(page)); gnc_plugin_update_actions (action_group, actions_requiring_owner_always, "sensitive", sensitive); gnc_plugin_update_actions (action_group, actions_requiring_owner_rw, "sensitive", sensitive && is_readwrite); g_signal_emit (page, plugin_page_signals[OWNER_SELECTED], 0, owner); }
void _fcitx_im_widget_im_selection_changed(GtkTreeSelection *selection, gpointer data) { FcitxImWidget* self = data; GtkTreeView *treeView = gtk_tree_selection_get_tree_view(selection); GtkTreeModel *model = gtk_tree_view_get_model(treeView); GtkTreeIter iter; if (gtk_tree_selection_get_selected(selection, &model, &iter)) { gtk_widget_set_sensitive(GTK_WIDGET(self->delimbutton), TRUE); gtk_widget_set_sensitive(GTK_WIDGET(self->configurebutton), TRUE); GtkTreePath* path = gtk_tree_model_get_path(model, &iter); gint* ind = gtk_tree_path_get_indices(path); gint n = gtk_tree_model_iter_n_children(model, NULL); if (ind) { gtk_widget_set_sensitive(GTK_WIDGET(self->moveupbutton), (*ind != 0)); gtk_widget_set_sensitive(GTK_WIDGET(self->movedownbutton), (*ind != n - 1)); } gtk_tree_path_free(path); } else { gtk_widget_set_sensitive(GTK_WIDGET(self->delimbutton), FALSE); gtk_widget_set_sensitive(GTK_WIDGET(self->configurebutton), FALSE); } }
static void _GuiGtkList_selectionChangedCallback (GtkTreeSelection *sel, gpointer void_me) { iam (GuiList); if (my selectionChangedCallback != NULL && ! my blockSelectionChangedCallback) { //Melder_casual ("Selection changed."); struct structGuiListEvent event = { GTK_WIDGET (gtk_tree_selection_get_tree_view (sel)) }; my selectionChangedCallback (my selectionChangedBoss, & event); } }
Php::Value GtkTreeSelection_::get_tree_view() { GtkTreeView *ret = gtk_tree_selection_get_tree_view (GTK_TREE_SELECTION(instance)); GtkTreeView_ *return_parsed = new GtkTreeView_(); return_parsed->set_instance((gpointer *)ret); return Php::Object("GtkTreeView", return_parsed); }
GtkWidget *menu_select(const char *name, MenuInfo *menu_info, GtkTreeSelection *selection) { GtkTreeView *tree = gtk_tree_selection_get_tree_view(selection); GtkWidget *menu = menu_connect(name, menu_info, GTK_WIDGET(tree)); g_signal_connect(selection, "changed", G_CALLBACK(on_selection_changed), menu); return menu; }
void fsearch_window_actions_update (FsearchApplicationWindow *self) { GtkTreeSelection *selection = fsearch_application_window_get_listview_selection (self); GtkTreeView *treeview = gtk_tree_selection_get_tree_view (selection); gint num_rows = 0; if (treeview) { GtkTreeModel *model = gtk_tree_view_get_model (treeview); if (model) { num_rows = gtk_tree_model_iter_n_children (model, NULL); } } GActionGroup *group = gtk_widget_get_action_group (GTK_WIDGET (self), "win"); g_assert (G_IS_SIMPLE_ACTION_GROUP (group)); gint num_rows_selected = gtk_tree_selection_count_selected_rows (selection); action_set_enabled (group, "select_all", num_rows); action_set_enabled (group, "deselect_all", num_rows_selected); action_set_enabled (group, "invert_selection", num_rows_selected); action_set_enabled (group, "copy_clipboard", num_rows_selected); action_set_enabled (group, "cut_clipboard", num_rows_selected); action_set_enabled (group, "delete_selection", num_rows_selected); action_set_enabled (group, "open", num_rows_selected); action_set_enabled (group, "open_with", num_rows_selected); action_set_enabled (group, "open_with_other", FALSE); action_set_enabled (group, "open_folder", num_rows_selected); action_set_enabled (group, "focus_search", TRUE); action_set_enabled (group, "toggle_focus", TRUE); action_set_enabled (group, "hide_window", TRUE); action_set_enabled (group, "update_database", TRUE); action_set_enabled (group, "show_menubar", TRUE); action_set_enabled (group, "show_statusbar", TRUE); action_set_enabled (group, "show_filter", TRUE); action_set_enabled (group, "show_search_button", TRUE); action_set_enabled (group, "show_name_column", FALSE); action_set_enabled (group, "show_path_column", TRUE); action_set_enabled (group, "show_type_column", TRUE); action_set_enabled (group, "show_size_column", TRUE); action_set_enabled (group, "show_modified_column", TRUE); FsearchConfig *config = fsearch_application_get_config (FSEARCH_APPLICATION_DEFAULT); action_set_active_bool (group, "show_menubar", config->show_menubar); action_set_active_bool (group, "show_statusbar", config->show_statusbar); action_set_active_bool (group, "show_filter", config->show_filter); action_set_active_bool (group, "show_search_button", config->show_search_button); action_set_active_bool (group, "search_in_path", config->search_in_path); action_set_active_bool (group, "search_mode", config->enable_regex); action_set_active_bool (group, "match_case", config->match_case); action_set_active_bool (group, "show_name_column", true); action_set_active_bool (group, "show_path_column", config->show_path_column); action_set_active_bool (group, "show_type_column", config->show_type_column); action_set_active_bool (group, "show_size_column", config->show_size_column); action_set_active_bool (group, "show_modified_column", config->show_modified_column); }
static void projects_tree_selection_changed (GtkTreeSelection *selection, gpointer user_data) { NotesArea *nadlg = (NotesArea *) user_data; GttProjectsTree *gpt = GTT_PROJECTS_TREE (gtk_tree_selection_get_tree_view (selection)); GttProject *prj = gtt_projects_tree_get_selected_project (gpt); notes_area_set_project (nadlg, prj); }
void AP_UnixDialog_Styles::event_SelectionChanged(GtkTreeSelection * selection) { GtkTreeView *tree = gtk_tree_selection_get_tree_view(selection); GtkTreeModel *model = gtk_tree_view_get_model(tree); GList *list = gtk_tree_selection_get_selected_rows(selection, &model); gpointer item = g_list_nth_data(list, 0); m_selectedStyle = reinterpret_cast<GtkTreePath *>(item); // refresh the previews _populatePreviews(false); }
/** * Fetch data from the selection of a treeview. Returns a GSList containing * the user_data pointers from the selected rows. If cfn != NULL, it will * be used to determine whether two entries are equal and drop all duplicate * items from the result list. Using cfn will significantly increase runtime. */ GSList * tree_selection_collect_data(GtkTreeSelection *selection, tree_selection_get_data_func gdf, GCompareFunc cfn) { collect_data_struct_t cdata; g_assert(NULL != selection); cdata.results = NULL; cdata.to_unselect = NULL; cdata.cfn = cfn; cdata.gdf = gdf; cdata.tv = gtk_tree_selection_get_tree_view(selection); if (GUI_PROPERTY(gui_debug) >= 3) { cdata.name = gtk_widget_get_name( GTK_WIDGET(gtk_tree_selection_get_tree_view(selection))); if (NULL == cdata.name) cdata.name = "<UNKNOWN>"; } else cdata.name = NULL; /* * Browse selected rows and gather data. */ gtk_tree_selection_selected_foreach(selection, tree_selection_collect_data_helper, &cdata); /* * Now unselect the rows from which we got data. */ g_slist_foreach(cdata.to_unselect, tree_selection_unselect_helper, selection); /* * Cleanup before exit. */ gm_slist_free_null(&cdata.to_unselect); return cdata.results; }
/** * * * \param * \param * * \return **/ static void gsb_reconcile_button_collapse_row_clicked (GtkButton *button, GtkTreeSelection *selection) { GtkTreeView *tree_view; GtkTreeModel *model; GtkTreeIter iter; GtkTreePath *path; if ( !gtk_tree_selection_get_selected (selection, &model, &iter)) return; path = gtk_tree_model_get_path (model, &iter); tree_view = gtk_tree_selection_get_tree_view (selection); gtk_tree_view_collapse_row (tree_view, path); }
/* Called when Add... button is clicked */ static void add_exclude(GtkButton *button, gpointer user_data) { /* Append new item */ GtkTreeIter row_iter; gtk_list_store_append(exclude_list, &row_iter); /* Add a %s to the command */ //gtk_list_store_set(actions_list, &row_iter, 1, "", -1); /* Set the first column to editing */ GtkTreePath* row_path = gtk_tree_model_get_path((GtkTreeModel*)exclude_list, &row_iter); GtkTreeView* treeview = gtk_tree_selection_get_tree_view(exclude_selection); GtkTreeViewColumn* column = gtk_tree_view_get_column(treeview, 0); gtk_tree_view_set_cursor(treeview, row_path, column, TRUE); gtk_tree_path_free(row_path); }
G_MODULE_EXPORT void subtitle_list_selection_changed_cb(GtkTreeSelection *ts, signal_user_data_t *ud) { GtkTreeModel *tm; GtkTreeIter iter; GValue *subsettings = NULL; int row; g_debug("subtitle_list_selection_changed_cb()"); if (gtk_tree_selection_get_selected(ts, &tm, &iter)) { GtkTreeIter piter; if (gtk_tree_model_iter_parent(tm, &piter, &iter)) { GtkTreePath *path; GtkTreeView *tv; gtk_tree_selection_select_iter(ts, &piter); path = gtk_tree_model_get_path(tm, &piter); tv = gtk_tree_selection_get_tree_view(ts); // Make the parent visible in scroll window if it is not. gtk_tree_view_scroll_to_cell(tv, path, NULL, FALSE, 0, 0); gtk_tree_path_free(path); return; } GtkTreePath *tp; gint *indices; GValue *subtitle_list; tp = gtk_tree_model_get_path(tm, &iter); indices = gtk_tree_path_get_indices(tp); row = indices[0]; gtk_tree_path_free(tp); subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list"); if (row >= 0 && row < ghb_array_len(subtitle_list)) subsettings = ghb_array_get_nth(subtitle_list, row); } subtitle_update_dialog_widgets(ud, subsettings); if (subsettings) { if (ghb_settings_get_boolean(subsettings, "SubtitleBurned")) { ghb_subtitle_exclusive_burn(ud, row); } } }
/** @brief (de)sensitize option tree buttons for selected option tree row Config dialog page buttons are de-sensitized if the row is the toolbar 'parent' @param selection pointer to selection @param model UNUSED @param path @param path_currently_selected UNUSED @param set data struct for the keybings option @return TRUE always (the row is always selectable) */ static gboolean _e2_bookmark_tree_selection_check_cb (GtkTreeSelection *selection, GtkTreeModel *model, GtkTreePath *path, gboolean path_currently_selected, E2_OptionSet *set) { GtkTreeIter iter; if (gtk_tree_model_get_iter (set->ex.tree.model, &iter, path)) { gchar *label; gtk_tree_model_get (set->ex.tree.model, &iter, 0, &label, -1); gboolean result = strcmp (label, _C(41)); g_free (label); GtkTreeView *view = gtk_tree_selection_get_tree_view (selection); NEEDCLOSEBGL e2_option_tree_adjust_buttons (view, result); NEEDOPENBGL }
/*! \brief Handles changes in the treeview selection. * \par Function Description * This is the callback function that is called every time the user * select a row the library treeview of the dialog. * * If the selection is not a selection of a footprint, it does * nothing. Otherwise it updates the preview and Element data. * * \param [in] selection The current selection in the treeview. * \param [in] user_data The library dialog. */ static void library_window_callback_tree_selection_changed (GtkTreeSelection * selection, gpointer user_data) { GtkTreeView *view; GtkTreeModel *model; GtkTreeIter iter; GhidLibraryWindow *library_window = (GhidLibraryWindow *) user_data; LibraryEntryType *entry = NULL; gchar *m4_args; if (!gtk_tree_selection_get_selected (selection, &model, &iter)) return; view = gtk_tree_selection_get_tree_view (selection); gtk_tree_model_get (model, &iter, MENU_ENTRY_COLUMN, &entry, -1); if (entry == NULL) return; /* -1 flags this is an element file part and the file path is in | entry->AllocateMemory. */ if (entry->Template == (char *) -1) { if (LoadElementToBuffer (PASTEBUFFER, entry->AllocatedMemory, true)) SetMode (PASTEBUFFER_MODE); goto out; } /* Otherwise, it's a m4 element and we need to create a string of | macro arguments to be passed to the library command in | LoadElementToBuffer() */ m4_args = g_strdup_printf ("'%s' '%s' '%s'", EMPTY (entry->Template), EMPTY (entry->Value), EMPTY (entry->Package)); if (LoadElementToBuffer (PASTEBUFFER, m4_args, false)) SetMode (PASTEBUFFER_MODE); g_free (m4_args); out: /* update the preview with new symbol data */ g_object_set (library_window->preview, "element-data", PASTEBUFFER->Data->Element, NULL); }
int clip_GTK_TREESELECTIONGETTREEVIEW(ClipMachine * cm) { C_object *ctreesel = _fetch_co_arg(cm); GtkTreeView *view; C_widget *cwid; CHECKOPT2(1, MAP_t, NUMERIC_t); CHECKCOBJ(ctreesel,GTK_IS_TREE_SELECTION(ctreesel->object)); view = gtk_tree_selection_get_tree_view(GTK_TREE_SELECTION(ctreesel->object)); if (!view) goto err; cwid = _register_widget(cm, GTK_WIDGET(view), NULL); _clip_mclone(cm,RETPTR(cm),&cwid->obj); return 0; err: return 1; }
static void onAbsenceSelectionChanged (GtkTreeSelection *sel,gpointer user_data) { GtkTreeIter selected_row; GtkWidget *text_view; GtkWidget *view; GtkWidget *entry; GtkTreeModel *model; GtkTextBuffer *buffer; gint index; gchar *title; gchar *message; view=GTK_WIDGET(gtk_tree_selection_get_tree_view(sel)); g_assert(view); g_assert(gtk_tree_selection_get_mode(sel) == GTK_SELECTION_SINGLE); entry=GTK_WIDGET(lookup_widget(view,"AbsenceTitleEntry")); g_assert(entry); text_view=GTK_WIDGET(lookup_widget(view,"fuzaiText")); g_assert(text_view); if (gtk_tree_selection_get_selected(sel, &model, &selected_row)) { gtk_tree_model_get (model, &selected_row, 1, &index, -1); dbg_out("Selected index:%d\n",index); if (!hostinfo_get_absent_title(index,(const char **)&title)) { gtk_entry_set_text(GTK_ENTRY(entry), title); g_free(title); } if (!hostinfo_get_absent_message(index, &message)) { buffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view)); gtk_text_buffer_set_text(buffer,message,-1); g_free(message); } } else { g_assert_not_reached(); } }
gint Meaning::_wordclick (GtkTreeSelection *sel, gpointer data) throw(std::bad_alloc) { Meaning *m = static_cast<Meaning*>(data); GtkTreeView *tv = gtk_tree_selection_get_tree_view(sel); GtkTreeModel *model = gtk_tree_view_get_model(tv); m->d_display._handleSelection(GTK_WIDGET(tv)); GtkTreeIter iter; if (gtk_tree_selection_get_selected (sel, &model, &iter)) { char* text; gtk_tree_model_get (model, 0, &text, -1); GdkEvent *e = gtk_get_current_event (); m->d_display._handleClick((e->type == GDK_2BUTTON_PRESS), text); } return 0; }
static void relation_list_sel_cb(GtkTreeSelection *sel, gpointer user_data _U_) { GtkWidget *window = gtk_widget_get_toplevel(GTK_WIDGET(gtk_tree_selection_get_tree_view(sel))); GtkWidget *range_label = (GtkWidget *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_RANGE_LABEL_KEY); GtkWidget *range_entry = (GtkWidget *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_RANGE_ENTRY_KEY); GtkWidget *value_label = (GtkWidget *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_VALUE_LABEL_KEY); GtkWidget *value_entry = (GtkWidget *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_VALUE_ENTRY_KEY); GtkWidget *value_list_label = (GtkWidget *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_VALUE_LIST_LABEL_KEY); GtkWidget *value_list = (GtkWidget *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_VALUE_LIST_KEY); GtkWidget *value_list_scrolled_win = (GtkWidget *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_VALUE_LIST_SW_KEY); header_field_info *hfinfo = (header_field_info *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_CURRENT_VAR_KEY); gchar *item_str; GtkTreeModel *model; GtkTreeIter iter; /* * What's the relation? */ if (!gtk_tree_selection_get_selected(sel, &model, &iter)) return; gtk_tree_model_get(model, &iter, 0, &item_str, -1); /* * Update the display of various items for the value, as appropriate. */ display_value_fields(hfinfo, !relation_is_presence_test(item_str), value_label, value_entry, value_list_label, value_list, value_list_scrolled_win, range_label, range_entry); g_free(item_str); }
void _fcitx_main_window_addon_selection_changed(GtkTreeSelection *selection, gpointer data) { GtkTreeView *treeView = gtk_tree_selection_get_tree_view(selection); GtkTreeModel *model = gtk_tree_view_get_model(treeView); GtkTreeIter iter; FcitxAddon *addon = NULL; FcitxMainWindow* self = data; if (!self->button) return; if (gtk_tree_selection_get_selected(selection, &model, &iter)) { gtk_tree_model_get(model, &iter, LIST_ADDON, &addon, -1); gchar* config_desc_name = g_strdup_printf("%s.desc", addon->name); FcitxConfigFileDesc* cfdesc = get_config_desc(config_desc_name); g_free(config_desc_name); gboolean configurable = (gboolean)(cfdesc != NULL || strlen(addon->subconfig) != 0); gtk_widget_set_sensitive(self->button, configurable); } else { gtk_widget_set_sensitive(self->button, FALSE); } }
static void treeview_selection_changed_callback (GtkTreeSelection *selection, guint data) { GSettings *settings; gchar *key; GtkTreeIter iter; GtkTreeModel *model; GtkTreeView *list; list = gtk_tree_selection_get_tree_view (selection); settings = g_object_get_data (G_OBJECT (list), GSETTINGS_SETTINGS); key = g_object_get_data (G_OBJECT (list), GSETTINGS_KEY); if (gtk_tree_selection_get_selected (selection, &model, &iter)) { gchar *list_value; gtk_tree_model_get (model, &iter, COL_NAME, &list_value, -1); if (list_value) { g_settings_set_string (settings, key, list_value); } } }
/** * called when change the selection of the fyear * * \param tree_selection * \param null * * \return FALSE * */ gboolean gsb_fyear_config_select ( GtkTreeSelection *tree_selection, gpointer null ) { GtkTreeModel *model; GtkTreeIter iter; gint fyear_number; GtkWidget *tree_view; GtkWidget *widget; if (!gtk_tree_selection_get_selected ( GTK_TREE_SELECTION (tree_selection), &model, &iter )) return FALSE; gtk_tree_model_get ( GTK_TREE_MODEL (model), &iter, FYEAR_NUMBER_COLUMN, &fyear_number, -1 ); tree_view = GTK_WIDGET (gtk_tree_selection_get_tree_view (tree_selection)); /* set the name */ widget = g_object_get_data ( G_OBJECT (model), "fyear_name_entry" ); gsb_autofunc_entry_set_value ( widget, gsb_data_fyear_get_name (fyear_number), fyear_number ); /* set the beginning date */ widget = g_object_get_data ( G_OBJECT (model), "fyear_begin_date_entry" ); gsb_calendar_entry_set_color (widget, TRUE); gsb_autofunc_date_set ( widget, gsb_data_fyear_get_beginning_date (fyear_number), fyear_number ); /* set the end date */ widget = g_object_get_data ( G_OBJECT (model), "fyear_end_date_entry" ); gsb_calendar_entry_set_color (widget, TRUE); gsb_autofunc_date_set ( widget, gsb_data_fyear_get_end_date (fyear_number), fyear_number ); /* set the button */ widget = g_object_get_data ( G_OBJECT (model), "fyear_show_button" ); gsb_autofunc_checkbutton_set_value ( widget, gsb_data_fyear_get_form_show (fyear_number), fyear_number ); /* set the invalid label */ widget = g_object_get_data ( G_OBJECT (model), "invalid_label" ); if (gsb_data_fyear_get_invalid (fyear_number)) { gtk_label_set_markup ( GTK_LABEL (widget), gsb_data_fyear_get_invalid_message (fyear_number)); gtk_widget_show (widget); } else gtk_widget_hide (widget); /* sensitive what is needed */ gtk_widget_set_sensitive ( g_object_get_data ( G_OBJECT (model), "paddingbox_details" ), TRUE ); gtk_widget_set_sensitive ( g_object_get_data ( G_OBJECT (model), "remove_fyear_button" ), TRUE ); return FALSE; }
gboolean on_key_treeview_selection ( GtkTreeSelection *selection, GtkTreeModel *model, GtkTreePath *path, gboolean path_currently_selected, gpointer userdata ) /* Global input: key_list - The list containing the settings for every key Global output: selected_key - Will point to the KTKeySettings in 'key_list' that corresponds to the selected key (if a key is selected) Description: This function sets all the settings of the selected key (if one selected) to the GUI and sets 'selected_key' to the address of the selected key settings. The key settings will be found in 'key_list'. */ { GtkEntry *program_entry = NULL, *default_entry, *plugin_combo_entry, *plugin_function_combo_entry; GtkRadioButton *radiobutton, *default_radiobutton, *program_radiobutton, *special_action_radiobutton; GtkList *plugin_combo_list, *plugin_function_combo_list; GtkTreeView *key_treeview; GtkTreeIter iter; char *key_name, *program_user = "", *default_action; KTPluginInfoEntry *plugin; /* If a row was selected instead of deselected */ if (gtk_tree_model_get_iter(model, &iter, path)) { /* Get the name of the selected key */ gtk_tree_model_get (model, &iter, FIRST_COLUMN, &key_name, -1); if (key_name != NULL) /* If a listitem was selected instead of deselected */ { key_treeview = gtk_tree_selection_get_tree_view(selection); program_entry = KTGUI_program_entry(); default_entry = KTGUI_default_entry(); plugin_combo_entry = KTGUI_plugin_combo_entry(); plugin_function_combo_entry = KTGUI_plugin_function_combo_entry(); default_radiobutton = KTGUI_default_radiobutton(); program_radiobutton = KTGUI_program_radiobutton(); special_action_radiobutton = KTGUI_special_action_radiobutton(); plugin_combo_list = KTGUI_plugin_combo_list(); plugin_function_combo_list = KTGUI_plugin_function_combo_list(); /* Block the signal handlers of the entries and the radiobuttons */ g_signal_handlers_block_by_func (GTK_OBJECT(program_entry), (void *)on_program_entry_changed, NULL); g_signal_handlers_block_by_func (GTK_OBJECT(default_radiobutton), (void *)on_default_radiobutton_toggled, NULL); g_signal_handlers_block_by_func (GTK_OBJECT(program_radiobutton), (void *)on_program_radiobutton_toggled, NULL); g_signal_handlers_block_by_func (GTK_OBJECT(special_action_radiobutton), (void *)on_special_action_radiobutton_toggled, NULL); g_signal_handlers_block_by_func (GTK_OBJECT(plugin_combo_entry), (void *)on_plugin_combo_entry_changed, NULL); g_signal_handlers_block_by_func (GTK_OBJECT(plugin_function_combo_entry), (void *)on_plugin_function_combo_entry_changed, NULL); gtk_entry_set_text (plugin_combo_entry, ""); gtk_entry_set_text (plugin_function_combo_entry, ""); /* Clear the plugin function list */ gtk_list_clear_items (plugin_function_combo_list, 0, -1); /* Clear the whole list */ /* Select the key in the linked list */ selected_key = find_key_settings(key_name, &key_list); /* Read the settings of the key */ if (!memcmp(&selected_key->action, &selected_key->default_action, sizeof(KTAction))) { radiobutton = default_radiobutton; } else if (selected_key->action.type == KTActionTypeProgram) { program_user = selected_key->action.program.command; radiobutton = GTK_RADIO_BUTTON( lookup_widget(GTK_WIDGET(key_treeview), "program_radiobutton") ); } else if (selected_key->action.type == KTActionTypePlugin) { plugin = find_plugin (selected_key->action.plugin.plugin_name, &plugin_list); if (plugin_function_exists (selected_key->action.plugin.plugin_name, selected_key->action.plugin.function_name, &plugin_list)) { reload_plugin_function_list (KTGUI_plugin_function_combo_list(), GTK_OBJECT( KTGUI_plugin_function_combo_entry() ), on_plugin_function_combo_entry_changed, plugin); gtk_entry_set_text (plugin_combo_entry, selected_key->action.plugin.plugin_name); gtk_entry_set_text (plugin_function_combo_entry, selected_key->action.plugin.function_name); radiobutton = special_action_radiobutton; } else { radiobutton = default_radiobutton; } } /* Show the settings of the key */ gtk_label_set_text (KTGUI_key_name_label(), key_name); gtk_entry_set_text (GTK_ENTRY(program_entry), program_user); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(radiobutton), TRUE); if (selected_key->default_action.type == KTActionTypePlugin) { /* If the plugin is not available on this system */ if (selected_key->default_action.plugin.plugin_name == NULL) { default_action = ""; } else { default_action = (char *)g_strdup_printf ("%s - %s", selected_key->default_action.plugin.plugin_name, selected_key->default_action.plugin.function_name); } } else if (selected_key->default_action.type == KTActionTypeProgram) { default_action = (char *)g_strdup_printf( selected_key->default_action.program.command); } /* Show the default action */ gtk_entry_set_text (GTK_ENTRY(default_entry), default_action); if (default_action[0] != '\0') { g_free (default_action); } /* Unblock the signal handlers of the entries and the radiobuttons */ g_signal_handlers_unblock_by_func (GTK_OBJECT(program_entry), (void *)on_program_entry_changed, NULL); g_signal_handlers_unblock_by_func (GTK_OBJECT(default_radiobutton), (void *)on_default_radiobutton_toggled, NULL); g_signal_handlers_unblock_by_func (GTK_OBJECT(program_radiobutton), (void *)on_program_radiobutton_toggled, NULL); g_signal_handlers_unblock_by_func (GTK_OBJECT(special_action_radiobutton), (void *)on_special_action_radiobutton_toggled, NULL); g_signal_handlers_unblock_by_func (GTK_OBJECT(plugin_combo_entry), (void *)on_plugin_combo_entry_changed, NULL); g_signal_handlers_unblock_by_func (GTK_OBJECT(plugin_function_combo_entry), (void *)on_plugin_function_combo_entry_changed, NULL); g_free (key_name); } } return (TRUE); }
// start helpers static void swap_buses (GtkTreeModel *tm, GtkTreeSelection *sel, bus_layout_D *dialog, GtkTreePath *tpSrc, GtkTreePath *tpDst) { int Nix ; GtkTreeIter itr ; SWAP_BUSES_STRUCT src, dst ; SWAP_BUSES_STRUCT *min = NULL, *max = NULL ; EXP_ARRAY *ar_bSelSrc = NULL, *ar_bSelDst = NULL ; gboolean bDstExpanded = TRUE ; if (!gtk_tree_model_get_iter (tm, &(src.itr), tpSrc)) return ; src.tp = gtk_tree_path_copy (tpSrc) ; src.icChildren = gtk_tree_model_iter_n_children (tm, &(src.itr)) ; if (!gtk_tree_model_get_iter (tm, &(dst.itr), tpDst)) { gtk_tree_path_free (src.tp) ; return ; } dst.tp = gtk_tree_path_copy (tpDst) ; dst.icChildren = gtk_tree_model_iter_n_children (tm, &(dst.itr)) ; if (dst.icChildren < src.icChildren) { min = &dst ; max = &src ; } else { min = &src ; max = &dst ; } bDstExpanded = gtk_tree_view_row_expanded (gtk_tree_selection_get_tree_view (sel), dst.tp) ; g_signal_handlers_block_matched (G_OBJECT (sel), G_SIGNAL_MATCH_FUNC, 0, 0, NULL, (gpointer)tree_view_selection_changed, NULL) ; for (Nix = 0 ; Nix < max->icChildren - min->icChildren ; Nix++) gtk_tree_store_append (GTK_TREE_STORE (tm), &itr, &(min->itr)) ; gtk_tree_path_down (src.tp) ; gtk_tree_path_down (dst.tp) ; ar_bSelSrc = exp_array_new (sizeof (gboolean), 1) ; ar_bSelDst = exp_array_new (sizeof (gboolean), 1) ; exp_array_1d_insert_vals (ar_bSelSrc, NULL, max->icChildren, 0) ; exp_array_1d_insert_vals (ar_bSelDst, NULL, max->icChildren, 0) ; for (Nix = 0 ; Nix < max->icChildren ; Nix++) { exp_array_index_1d (ar_bSelSrc, gboolean, Nix) = gtk_tree_selection_path_is_selected (sel, src.tp) ; exp_array_index_1d (ar_bSelDst, gboolean, Nix) = gtk_tree_selection_path_is_selected (sel, dst.tp) ; gtk_tree_path_next (src.tp) ; gtk_tree_path_next (dst.tp) ; } if (!gtk_tree_path_up (src.tp)) goto swap_buses_quit ; if (!gtk_tree_path_up (dst.tp)) goto swap_buses_quit ; gtk_tree_path_down (src.tp) ; gtk_tree_path_down (dst.tp) ; for (Nix = 0 ; Nix < max->icChildren ; Nix++) { if (exp_array_index_1d (ar_bSelDst, gboolean, Nix)) gtk_tree_view_expand_to_path (gtk_tree_selection_get_tree_view (sel), src.tp) ; if (exp_array_index_1d (ar_bSelSrc, gboolean, Nix)) gtk_tree_view_expand_to_path (gtk_tree_selection_get_tree_view (sel), dst.tp) ; gtk_tree_path_next (src.tp) ; gtk_tree_path_next (dst.tp) ; } if (!gtk_tree_path_up (src.tp)) goto swap_buses_quit ; if (!gtk_tree_path_up (dst.tp)) goto swap_buses_quit ; gtk_tree_path_down (src.tp) ; gtk_tree_path_down (dst.tp) ; for (Nix = 0 ; Nix < max->icChildren ; Nix++) { swap_model_paths_contents (tm, src.tp, dst.tp) ; gtk_tree_path_next (src.tp) ; gtk_tree_path_next (dst.tp) ; } if (!gtk_tree_path_up (src.tp)) goto swap_buses_quit ; if (!gtk_tree_path_up (dst.tp)) goto swap_buses_quit ; gtk_tree_path_down (src.tp) ; gtk_tree_path_down (dst.tp) ; for (Nix = 0 ; Nix < max->icChildren ; Nix++) { GTK_TREE_SELECTION_SET_PATH_SELECTED (sel, src.tp, exp_array_index_1d (ar_bSelDst, gboolean, Nix)) ; GTK_TREE_SELECTION_SET_PATH_SELECTED (sel, dst.tp, exp_array_index_1d (ar_bSelSrc, gboolean, Nix)) ; gtk_tree_path_next (src.tp) ; gtk_tree_path_next (dst.tp) ; } if (!gtk_tree_path_up (src.tp)) goto swap_buses_quit ; if (!gtk_tree_path_up (dst.tp)) goto swap_buses_quit ; swap_model_paths_contents (tm, src.tp, dst.tp) ; gtk_tree_path_down (src.tp) ; gtk_tree_path_down (dst.tp) ; for (Nix = 0 ; Nix < min->icChildren ; Nix++) gtk_tree_path_next (max->tp) ; if (gtk_tree_model_get_iter (tm, &itr, max->tp)) while (gtk_tree_store_remove (GTK_TREE_STORE (tm), &itr)) ; if (!bDstExpanded) { for (Nix = 0 ; Nix < ar_bSelDst->icUsed ; Nix++) if (exp_array_index_1d (ar_bSelDst, gboolean, Nix)) break ; if (Nix == ar_bSelDst->icUsed) if (gtk_tree_path_up (src.tp)) gtk_tree_view_collapse_row (gtk_tree_selection_get_tree_view (sel), src.tp) ; } swap_buses_quit: exp_array_free (ar_bSelSrc) ; exp_array_free (ar_bSelDst) ; gtk_tree_path_free (src.tp) ; gtk_tree_path_free (dst.tp) ; g_signal_handlers_unblock_matched (G_OBJECT (sel), G_SIGNAL_MATCH_FUNC, 0, 0, NULL, (gpointer)tree_view_selection_changed, NULL) ; tree_view_selection_changed (sel, dialog) ; }
static void pn_move (struct pan_node *xq, gint x, gint y, gint nx, gint ny) { GtkWidget *dia; char mes[0x100]; int isover; struct xq_move *move; GtkTreeIter iter[1]; GtkTreePath *path; GtkTreeView *tree; acc_debug ("move [%s] [%d:%d] -> [%d:%d]\n", zi_chinese[(int) xq->cur_pan[y][x]], x, y, nx, ny); if (xq->move_count >= sizeof (xq->moves) / sizeof (xq->moves[0])) { acc_err ( _("move count error.\n")); return; } move = xq->moves + xq->move_count; xq->move_count ++; move->dead = xq->cur_pan[ny][nx]; move->isred = IS_RED (xq->cur_pan[y][x]); move->fromx = x; move->fromy = y; move->tox = nx; move->toy = ny; move_to_desc (xq->cur_pan, move, mes, sizeof mes); gtk_list_store_append (GTK_LIST_STORE (xq->qipu_list), iter); gtk_list_store_set (GTK_LIST_STORE (xq->qipu_list), iter, 1, mes, -1); path = gtk_tree_model_get_path (GTK_TREE_MODEL (xq->qipu_list), iter); if (path) { tree = gtk_tree_selection_get_tree_view (GTK_TREE_SELECTION (xq->qipu_sel)); gtk_tree_view_scroll_to_cell (tree, path, NULL, FALSE, 0, 0); gtk_tree_path_free (path); } pan_move (xq->cur_pan, x, y, nx, ny); if (move->dead) { xq->cur_moves = NULL; memcpy (xq->cur_fen, xq->cur_pan, 10 * 9 * sizeof (char)); xq->cur_fen->half_count = 0; if (IS_RED (move->dead)) { xq->cur_fen->is_redturn = 1; } else { xq->cur_fen->is_redturn = 0; } } else { xq->cur_moves = g_list_append (xq->cur_moves, move); xq->cur_fen->half_count ++; } isover = zgxq_is_over (xq->cur_pan); if (isover) { xq->state = PAN_STATE_GAME_OVER; g_snprintf (mes, sizeof mes, _("!!!Game over. You %s.\n"), isover > 0 ? _("WIN") : _("LOSE")); dia = gtk_message_dialog_new (NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE, mes); gtk_dialog_run (GTK_DIALOG (dia)); gtk_widget_destroy (dia); g_signal_emit_by_name (xq->bstop, "clicked", xq); } }
gboolean on_key_treeview_selection ( GtkTreeSelection *selection, GtkTreeModel *model, GtkTreePath *path, gboolean path_currently_selected, gpointer userdata ) { GtkLabel *key_name_label = NULL; GtkEntry *program_entry = NULL, *default_entry, *special_action_combo_entry; GtkRadioButton *radiobutton, *default_radiobutton, *program_radiobutton, *special_action_radiobutton; GtkList *special_action_list; GtkTreeView *key_treeview; GtkTreeIter iter; char *key_name, *program_user = "", *program_default; KEY_SETTINGS *selected_key; key_treeview = gtk_tree_selection_get_tree_view(selection); key_name_label = GTK_LABEL( lookup_widget(GTK_WIDGET(key_treeview), "key_name_label") ); program_entry = GTK_ENTRY( lookup_widget(GTK_WIDGET(key_treeview), "program_entry") ); default_entry = GTK_ENTRY( lookup_widget(GTK_WIDGET(key_treeview), "default_entry") ); if ( gtk_tree_model_get_iter(model, &iter, path) ) /* If a row was selected instead of deselected */ { /* Get the name of the selected key */ gtk_tree_model_get (model, &iter, FIRST_COLUMN, &key_name, -1); if (key_name) /* If a listitem was selected instead of deselected */ { default_radiobutton = GTK_RADIO_BUTTON( lookup_widget(GTK_WIDGET(key_treeview), "default_radiobutton") ); program_radiobutton = GTK_RADIO_BUTTON( lookup_widget(GTK_WIDGET(key_treeview), "program_radiobutton") ); special_action_radiobutton = GTK_RADIO_BUTTON( lookup_widget(GTK_WIDGET(key_treeview), "special_action_radiobutton") ); special_action_combo_entry = GTK_ENTRY( lookup_widget(GTK_WIDGET(key_treeview), "special_action_combo_entry") ); special_action_list = GTK_COMBO(lookup_widget(GTK_WIDGET(key_treeview), "special_action_combo"))->list; /* Block the signal handlers of the entries and the radiobuttons */ gtk_signal_handler_block_by_func ( GTK_OBJECT(program_entry), (void *)on_program_entry_changed, NULL ); gtk_signal_handler_block_by_func ( GTK_OBJECT(default_radiobutton), (void *)on_default_radiobutton_toggled, NULL ); gtk_signal_handler_block_by_func ( GTK_OBJECT(program_radiobutton), (void *)on_program_radiobutton_toggled, NULL ); gtk_signal_handler_block_by_func ( GTK_OBJECT(special_action_radiobutton), (void *)on_special_action_radiobutton_toggled, NULL ); gtk_signal_handler_block_by_func ( GTK_OBJECT(special_action_combo_entry), (void *)on_special_action_combo_entry_changed, NULL ); /* Select the first item of special_action_list */ /* Select the matching list item of special_action_list */ gtk_list_select_item (GTK_LIST(special_action_list), 0); /* Select the key in the linked list */ selected_key = ksl_find_key( kbcfg_key_settings_list(¤t_keyboard_config), key_name ); /* Read the settings of the key */ if ( strcmp( ks_get_program_user(selected_key), "default" ) == EQUAL ) { radiobutton = default_radiobutton; } else if ( (*ks_get_program_user(selected_key) == ':') && (select_special_action(&plugin_list, ks_get_program_user(selected_key), special_action_list)) ) { radiobutton = special_action_radiobutton; } else { program_user = ks_get_program_user(selected_key); radiobutton = GTK_RADIO_BUTTON( lookup_widget(GTK_WIDGET(key_treeview), "program_radiobutton") ); } /* Show the settings of the key */ gtk_label_set_text (GTK_LABEL(key_name_label), key_name); gtk_entry_set_text (GTK_ENTRY(program_entry), program_user); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(radiobutton), TRUE); program_default = ks_get_program_default(selected_key); if (program_default[0] == ':') /* If program_default is a special action */ { program_default++; /* Now the user only sees the name of the special action */ } gtk_entry_set_text (GTK_ENTRY(default_entry), program_default); /* Unblock the signal handlers of the entries and the radiobuttons */ gtk_signal_handler_unblock_by_func ( GTK_OBJECT(program_entry), (void *)on_program_entry_changed, NULL ); gtk_signal_handler_unblock_by_func ( GTK_OBJECT(default_radiobutton), (void *)on_default_radiobutton_toggled, NULL ); gtk_signal_handler_unblock_by_func ( GTK_OBJECT(program_radiobutton), (void *)on_program_radiobutton_toggled, NULL ); gtk_signal_handler_unblock_by_func ( GTK_OBJECT(special_action_radiobutton), (void *)on_special_action_radiobutton_toggled, NULL ); gtk_signal_handler_unblock_by_func ( GTK_OBJECT(special_action_combo_entry), (void *)on_special_action_combo_entry_changed, NULL ); } } return (TRUE); }
/** * called when select a link * * \param tree_selection * \param null not used * * \return FALSE * */ gboolean gsb_currency_link_config_select_currency ( GtkTreeSelection *tree_selection, gpointer null ) { GtkTreeModel *model; GtkTreeIter iter; gint link_number; GtkWidget *combobox_1; GtkWidget *combobox_2; GtkWidget *exchange_entry; GtkWidget *tree_view; GtkWidget *label; GtkWidget *button; gchar* tmpstr; if (!gtk_tree_selection_get_selected ( GTK_TREE_SELECTION (tree_selection), &model, &iter )) return FALSE; gtk_tree_model_get ( GTK_TREE_MODEL (model), &iter, LINK_NUMBER_COLUMN, &link_number, -1 ); /* normally should not happen */ if (!link_number) return FALSE; gtk_widget_set_sensitive ( GTK_WIDGET ( g_object_get_data ( G_OBJECT ( model ), "hbox_line") ), TRUE ); combobox_1 = g_object_get_data ( G_OBJECT (model), "combobox_1" ); combobox_2 = g_object_get_data ( G_OBJECT (model), "combobox_2" ); exchange_entry = g_object_get_data ( G_OBJECT (model), "exchange_entry" ); button = g_object_get_data ( G_OBJECT (model), "fixed_button" ); gtk_widget_set_sensitive ( button, TRUE ); tree_view = GTK_WIDGET ( gtk_tree_selection_get_tree_view ( tree_selection ) ); g_signal_handlers_block_by_func ( G_OBJECT (combobox_1), G_CALLBACK (gsb_currency_link_config_modify_link), tree_view ); gsb_currency_set_combobox_history ( combobox_1, gsb_data_currency_link_get_first_currency (link_number)); g_signal_handlers_unblock_by_func ( G_OBJECT (combobox_1), G_CALLBACK (gsb_currency_link_config_modify_link), tree_view ); g_signal_handlers_block_by_func ( G_OBJECT (combobox_2), G_CALLBACK (gsb_currency_link_config_modify_link), tree_view ); gsb_currency_set_combobox_history ( combobox_2, gsb_data_currency_link_get_second_currency (link_number)); g_signal_handlers_unblock_by_func ( G_OBJECT (combobox_2), G_CALLBACK (gsb_currency_link_config_modify_link), tree_view ); g_signal_handlers_block_by_func ( G_OBJECT (exchange_entry), G_CALLBACK (gsb_currency_link_config_modify_link), tree_view ); tmpstr = utils_real_get_string (gsb_data_currency_link_get_change_rate (link_number)); gtk_entry_set_text ( GTK_ENTRY (exchange_entry), tmpstr); g_free ( tmpstr ); g_signal_handlers_unblock_by_func ( G_OBJECT (exchange_entry), G_CALLBACK (gsb_currency_link_config_modify_link), tree_view ); /* set the fixed_link flag */ g_signal_handlers_block_by_func ( G_OBJECT ( button ), G_CALLBACK ( gsb_currency_link_config_button_fixed_changed ), tree_view ); gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON ( button ), gsb_data_currency_link_get_fixed_link ( link_number ) ); g_signal_handlers_unblock_by_func ( G_OBJECT ( button ), G_CALLBACK ( gsb_currency_link_config_button_fixed_changed ), tree_view ); /* set or hide the warning label */ label = g_object_get_data (G_OBJECT (model), "warning_label"); if ( gsb_data_currency_link_get_invalid_link (link_number)) { gtk_label_set_markup ( GTK_LABEL (label), gsb_data_currency_link_get_invalid_message (link_number)); gtk_widget_show (label); } else gtk_widget_hide (label); return FALSE; }