void clist_init(void) { GtkTreeView *view = GTK_TREE_VIEW(clist_wnd); GtkTreeModel *model = GTK_TREE_MODEL(list); GtkCellRenderer *renderer; GtkTreeSelection *selection; gint i; list = gtk_list_store_new(CLIST_NCOLS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER ); model = GTK_TREE_MODEL(list); gtk_tree_view_set_model(view, model); gtk_tree_view_set_headers_visible(view, TRUE); gtk_tree_view_set_headers_clickable(view, TRUE); gtk_tree_view_set_rules_hint(view, FALSE); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_insert_column_with_attributes(view, -1, "", renderer, "pixbuf", COLUMN_ICON, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Name"), renderer, "text", COLUMN_NAME, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Type"), renderer, "text", COLUMN_TYPE, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Size"), renderer, "text", COLUMN_SIZE, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Date"), renderer, "text", COLUMN_DATE, NULL); for (i = 0; i < CLIST_NVCOLS; i++) { GtkTreeViewColumn *col; col = gtk_tree_view_get_column(view, i); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_column_set_clickable(col, TRUE); g_signal_connect(G_OBJECT(col), "clicked", G_CALLBACK(column_clicked), view); } selection = gtk_tree_view_get_selection(view); gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); gtk_tree_selection_set_select_function(selection, select_func, NULL, NULL); g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(tree_selection_changed), NULL); }
void linphone_gtk_call_log_update(GtkWidget *w){ GtkTreeView *v=GTK_TREE_VIEW(linphone_gtk_get_widget(w,"logs_view")); GtkTreeStore *store; const MSList *logs; GtkTreeSelection *select; GtkWidget *notebook=linphone_gtk_get_widget(w,"viewswitch"); gint nb; store=(GtkTreeStore*)gtk_tree_view_get_model(v); if (store==NULL){ store=gtk_tree_store_new(3,GDK_TYPE_PIXBUF,G_TYPE_STRING,G_TYPE_POINTER,G_TYPE_STRING); gtk_tree_view_set_model(v,GTK_TREE_MODEL(store)); g_object_unref(G_OBJECT(store)); fill_renderers(GTK_TREE_VIEW(linphone_gtk_get_widget(w,"logs_view"))); select=gtk_tree_view_get_selection(v); gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE); g_signal_connect_swapped(G_OBJECT(select),"changed",(GCallback)call_log_selection_changed,v); g_signal_connect(G_OBJECT(notebook),"focus-tab",(GCallback)linphone_gtk_call_log_reset_missed_call,NULL); g_signal_connect(G_OBJECT(v),"button-press-event",(GCallback)linphone_gtk_call_log_button_pressed,NULL); // gtk_button_set_image(GTK_BUTTON(linphone_gtk_get_widget(w,"call_back_button")), // create_pixmap (linphone_gtk_get_ui_config("callback_button","status-green.png"))); } nb=linphone_core_get_missed_calls_count(linphone_gtk_get_core()); if(nb > 0) linphone_gtk_call_log_display_missed_call(nb); gtk_tree_store_clear (store); for (logs=linphone_core_get_call_logs(linphone_gtk_get_core());logs!=NULL;logs=logs->next){ LinphoneCallLog *cl=(LinphoneCallLog*)logs->data; GtkTreeIter iter, iter2; LinphoneAddress *la=linphone_call_log_get_dir(cl)==LinphoneCallIncoming ? linphone_call_log_get_from(cl) : linphone_call_log_get_to(cl); char *addr= linphone_address_as_string(la); const char *display; gchar *logtxt, *headtxt, *minutes, *seconds; gchar quality[20]; const char *status=NULL; gchar *start_date=NULL; LinphoneFriend *lf=NULL; int duration=linphone_call_log_get_duration(cl); time_t start_date_time=linphone_call_log_get_start_date(cl); #if GLIB_CHECK_VERSION(2,26,0) if (start_date_time){ GDateTime *dt=g_date_time_new_from_unix_local(start_date_time); start_date=g_date_time_format(dt,"%c"); g_date_time_unref(dt); } #else start_date=g_strdup(ctime(&start_date_time)); #endif lf=linphone_core_get_friend_by_address(linphone_gtk_get_core(),addr); if(lf != NULL){ display=linphone_address_get_display_name(linphone_friend_get_address(lf)); } else { display=linphone_address_get_display_name(la); } if (display==NULL){ display=linphone_address_get_username (la); if (display==NULL){ display=linphone_address_get_domain (la); } } else { linphone_address_set_display_name(la,display); } if (linphone_call_log_get_quality(cl)!=-1){ snprintf(quality,sizeof(quality),"%.1f",linphone_call_log_get_quality(cl)); }else snprintf(quality,sizeof(quality)-1,"%s",_("n/a")); switch(linphone_call_log_get_status(cl)){ case LinphoneCallAborted: status=_("Aborted"); break; case LinphoneCallMissed: status=_("Missed"); break; case LinphoneCallDeclined: status=_("Declined"); break; default: break; } minutes=g_markup_printf_escaped( ngettext("%i minute", "%i minutes", duration/60), duration/60); seconds=g_markup_printf_escaped( ngettext("%i second", "%i seconds", duration%60), duration%60); if (status==NULL) { headtxt=g_markup_printf_escaped(_("<big><b>%s</b></big>\t%s"),display,start_date ? start_date : ""); logtxt=g_markup_printf_escaped( _("<small><i>%s</i>\t" "<i>Quality: %s</i></small>\n%s\t%s\t"), addr, quality, minutes, seconds); } else { headtxt=g_markup_printf_escaped(_("<big><b>%s</b></big>\t%s"),display,start_date ? start_date : ""); logtxt=g_markup_printf_escaped( _("<small><i>%s</i></small>\t" "\n%s"),addr, status); } g_free(minutes); g_free(seconds); if (start_date) g_free(start_date); gtk_tree_store_append (store,&iter,NULL); GdkPixbuf *incoming = create_pixbuf("call_status_incoming.png"); GdkPixbuf *outgoing = create_pixbuf("call_status_outgoing.png"); gtk_tree_store_set (store,&iter, 0, linphone_call_log_get_dir(cl)==LinphoneCallOutgoing ? outgoing : incoming, 1, headtxt,2,cl,-1); gtk_tree_store_append (store,&iter2,&iter); gtk_tree_store_set (store,&iter2,1,logtxt,-1); ms_free(addr); g_free(logtxt); g_free(headtxt); } }
GtkWidget * do_stock_browser (GtkWidget *do_widget) { if (!window) { GtkWidget *frame; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *sw; GtkWidget *treeview; GtkWidget *align; GtkTreeModel *model; GtkCellRenderer *cell_renderer; StockItemDisplay *display; GtkTreeSelection *selection; GtkTreeViewColumn *column; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_screen (GTK_WINDOW (window), gtk_widget_get_screen (do_widget)); gtk_window_set_title (GTK_WINDOW (window), "Stock Icons and Items"); gtk_window_set_default_size (GTK_WINDOW (window), -1, 500); g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window); gtk_container_set_border_width (GTK_CONTAINER (window), 8); hbox = gtk_hbox_new (FALSE, 8); gtk_container_add (GTK_CONTAINER (window), hbox); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (hbox), sw, FALSE, FALSE, 0); model = create_model (); treeview = gtk_tree_view_new_with_model (model); g_object_unref (model); gtk_container_add (GTK_CONTAINER (sw), treeview); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, "Macro"); cell_renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, cell_renderer, FALSE); gtk_tree_view_column_set_attributes (column, cell_renderer, "stock_id", 1, NULL); cell_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell_renderer, TRUE); gtk_tree_view_column_set_cell_data_func (column, cell_renderer, macro_set_func_text, NULL, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); cell_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (treeview), -1, "Label", cell_renderer, label_set_func, NULL, NULL); cell_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (treeview), -1, "Accel", cell_renderer, accel_set_func, NULL, NULL); cell_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (treeview), -1, "ID", cell_renderer, id_set_func, NULL, NULL); align = gtk_alignment_new (0.5, 0.0, 0.0, 0.0); gtk_box_pack_end (GTK_BOX (hbox), align, FALSE, FALSE, 0); frame = gtk_frame_new ("Selected Item"); gtk_container_add (GTK_CONTAINER (align), frame); vbox = gtk_vbox_new (FALSE, 8); gtk_container_set_border_width (GTK_CONTAINER (vbox), 4); gtk_container_add (GTK_CONTAINER (frame), vbox); display = g_new (StockItemDisplay, 1); g_object_set_data_full (G_OBJECT (treeview), "stock-display", display, g_free); /* free display with treeview */ display->type_label = gtk_label_new (NULL); display->macro_label = gtk_label_new (NULL); display->id_label = gtk_label_new (NULL); display->label_accel_label = gtk_label_new (NULL); display->icon_image = gtk_image_new_from_pixbuf (NULL); /* empty image */ gtk_box_pack_start (GTK_BOX (vbox), display->type_label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), display->icon_image, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), display->label_accel_label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), display->macro_label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), display->id_label, FALSE, FALSE, 0); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect (selection, "changed", G_CALLBACK (selection_changed), NULL); } if (!gtk_widget_get_visible (window)) { gtk_widget_show_all (window); } else { gtk_widget_destroy (window); window = NULL; } return window; }
G_MODULE_EXPORT void on_item_application_access_toggled (GtkCheckButton *check, BastileWidget *swidget) { BastileObject *object; BastileGkrItem *git; BastileOperation *op; MateKeyringAccessType access; MateKeyringAccessControl *ac; GtkTreeView *tree; GtkTreePath *path; GtkTreeModel *model; GtkTreeIter iter; GtkTreeSelection *selection; GError *err = NULL; GList *acl; /* Just us setting up the controls, not the user */ if (g_object_get_data (G_OBJECT (swidget), "updating")) return; object = BASTILE_OBJECT_WIDGET (swidget)->object; git = BASTILE_GKR_ITEM (object); tree = GTK_TREE_VIEW (bastile_widget_get_widget (swidget, "application-list")); g_return_if_fail (GTK_IS_TREE_VIEW (tree)); selection = gtk_tree_view_get_selection (tree); if (!gtk_tree_selection_get_selected (selection, &model, &iter)) g_return_if_reached (); path = gtk_tree_model_get_path (model, &iter); g_return_if_fail (path); /* Update the access control on that one */ gtk_tree_model_get (model, &iter, APPS_ACCESS, &ac, -1); access = mate_keyring_item_ac_get_access_type (ac); merge_toggle_button_access (swidget, "application-read", &access, MATE_KEYRING_ACCESS_READ); merge_toggle_button_access (swidget, "application-write", &access, MATE_KEYRING_ACCESS_WRITE); merge_toggle_button_access (swidget, "application-delete", &access, MATE_KEYRING_ACCESS_REMOVE); /* If it's changed */ if (access != mate_keyring_item_ac_get_access_type (ac)) { /* Update the store with this new stuff */ mate_keyring_item_ac_set_access_type (ac, access); gtk_list_store_set (GTK_LIST_STORE (model), &iter, APPS_ACCESS, ac, -1); mate_keyring_access_control_free (ac); /* Build up a full ACL from what we have */ acl = NULL; if (!gtk_tree_model_get_iter_first (model, &iter)) g_return_if_reached (); do { gtk_tree_model_get (model, &iter, APPS_ACCESS, &ac, -1); acl = g_list_append (acl, ac); } while (gtk_tree_model_iter_next (model, &iter)); bastile_widget_set_sensitive (swidget, "application-details", FALSE); g_object_ref (git); op = bastile_gkr_operation_update_acl (git, acl); g_return_if_fail (op); bastile_operation_wait (op); mate_keyring_acl_free (acl); if (!bastile_operation_is_successful (op)) update_application_details (swidget); bastile_widget_set_sensitive (swidget, "application-details", TRUE); g_object_unref (git); if (!bastile_operation_is_successful (op)) { bastile_operation_copy_error (op, &err); bastile_util_handle_error (err, _("Couldn't set application access.")); g_clear_error (&err); } g_object_unref (op); } }
void ghb_audio_list_refresh_selected(signal_user_data_t *ud) { GtkTreeView *treeview; GtkTreePath *treepath; GtkTreeSelection *selection; GtkTreeModel *store; GtkTreeIter iter; gint *indices; gint row; GValue *asettings = NULL; const GValue *audio_list; g_debug("ghb_audio_list_refresh_selected ()"); treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "audio_list")); selection = gtk_tree_view_get_selection (treeview); if (gtk_tree_selection_get_selected(selection, &store, &iter)) { const gchar *track, *codec, *br = NULL, *sr, *mix; gchar *s_drc, *s_gain, *s_quality = NULL; gdouble drc, gain; // Get the row number treepath = gtk_tree_model_get_path (store, &iter); indices = gtk_tree_path_get_indices (treepath); row = indices[0]; gtk_tree_path_free(treepath); // find audio settings if (row < 0) return; audio_list = ghb_settings_get_value(ud->settings, "audio_list"); if (row >= ghb_array_len(audio_list)) return; asettings = ghb_array_get_nth(audio_list, row); track = ghb_settings_combo_option(asettings, "AudioTrack"); codec = ghb_settings_combo_option(asettings, "AudioEncoderActual"); double quality = ghb_settings_get_double(asettings, "AudioTrackQuality"); if (ghb_settings_get_boolean(asettings, "AudioTrackQualityEnable") && quality != HB_INVALID_AUDIO_QUALITY) { int codec = ghb_settings_combo_int(asettings, "AudioEncoderActual"); s_quality = ghb_format_quality("Q/", codec, quality); } else { br = ghb_settings_combo_option(asettings, "AudioBitrate"); } sr = ghb_settings_combo_option(asettings, "AudioSamplerate"); mix = ghb_settings_combo_option(asettings, "AudioMixdown"); gain = ghb_settings_get_double(asettings, "AudioTrackGain"); s_gain = g_strdup_printf("%ddB", (int)gain); drc = ghb_settings_get_double(asettings, "AudioTrackDRCSlider"); if (drc < 1.0) s_drc = g_strdup("Off"); else s_drc = g_strdup_printf("%.1f", drc); gtk_list_store_set(GTK_LIST_STORE(store), &iter, // These are displayed in list 0, track, 1, codec, 2, s_quality ? s_quality : br, 3, sr, 4, mix, 5, s_gain, 6, s_drc, -1); g_free(s_drc); g_free(s_gain); g_free(s_quality); } }
// run the cheat list dialog void RunCheatListDialog() { GtkWidget *widget; GtkTreeSelection *treesel; GtkTreeViewColumn *column; GtkCellRenderer *renderer; builder = gtk_builder_new(); if (!gtk_builder_add_from_file(builder, PACKAGE_DATA_DIR "pcsxr.ui", NULL)) { g_warning("Error: interface could not be loaded!"); return; } CheatListDlg = gtk_builder_get_object(builder, "CheatListDlg"); gtk_window_set_title(GTK_WINDOW(CheatListDlg), _("Cheat Codes")); gtk_widget_show (CheatListDlg); widget = gtk_builder_get_object(builder, "GtkCList_Cheat"); // column for enable renderer = gtk_cell_renderer_toggle_new(); column = gtk_tree_view_column_new_with_attributes(_("Enable"), renderer, "active", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(widget), column); g_signal_connect(G_OBJECT(renderer), "toggled", G_CALLBACK(OnCheatListDlg_EnableToggled), 0); // column for description renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Description"), renderer, "text", 1, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(widget), column); LoadCheatListItems(-1); treesel = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget)); gtk_tree_selection_set_mode(treesel, GTK_SELECTION_SINGLE); g_signal_connect_data(G_OBJECT (treesel), "changed", G_CALLBACK (CheatList_TreeSelectionChanged), NULL, NULL, G_CONNECT_AFTER); widget = gtk_builder_get_object(builder, "addbutton1"); g_signal_connect_data(G_OBJECT(widget), "clicked", G_CALLBACK(OnCheatListDlg_AddClicked), builder, NULL, G_CONNECT_AFTER); widget = gtk_builder_get_object(builder, "editbutton1"); g_signal_connect_data(G_OBJECT(widget), "clicked", G_CALLBACK(OnCheatListDlg_EditClicked), builder, NULL, G_CONNECT_AFTER); widget = gtk_builder_get_object(builder, "delbutton1"); g_signal_connect_data(G_OBJECT(widget), "clicked", G_CALLBACK(OnCheatListDlg_DelClicked), builder, NULL, G_CONNECT_AFTER); widget = gtk_builder_get_object(builder, "loadbutton1"); g_signal_connect_data(G_OBJECT(widget), "clicked", G_CALLBACK(OnCheatListDlg_OpenClicked), builder, NULL, G_CONNECT_AFTER); widget = gtk_builder_get_object(builder, "savebutton1"); g_signal_connect_data(G_OBJECT(widget), "clicked", G_CALLBACK(OnCheatListDlg_SaveClicked), builder, NULL, G_CONNECT_AFTER); // Setup a handler for when Close or Cancel is clicked g_signal_connect_data(G_OBJECT(CheatListDlg), "response", G_CALLBACK(OnCheatListDlg_CloseClicked), builder, (GClosureNotify)g_object_unref, G_CONNECT_AFTER); gtk_widget_set_sensitive(GTK_WIDGET(gtk_builder_get_object(builder, "savebutton1")), NumCheats); gtk_widget_set_sensitive(GTK_WIDGET(gtk_builder_get_object(builder, "editbutton1")), FALSE); gtk_widget_set_sensitive(GTK_WIDGET(gtk_builder_get_object(builder, "delbutton1")), FALSE); gtk_widget_set_sensitive(GTK_WIDGET(gtk_builder_get_object(builder, "editbutton1")), FALSE); }
/* * Selects a single owner in the owner tree view. The owner * tree must be in single selection mode. */ void gnc_tree_view_owner_set_selected_owner (GncTreeViewOwner *view, GncOwner *owner) { GtkTreeModel *model, *f_model, *s_model; GtkTreePath *path, *f_path, *s_path, *parent_path; GtkTreeSelection *selection; ENTER("view %p, owner %p (%s)", view, owner, gncOwnerGetName (owner)); g_return_if_fail (GNC_IS_TREE_VIEW_OWNER (view)); /* Clear any existing selection. */ selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view)); gtk_tree_selection_unselect_all (selection); if (owner == NULL) return; s_model = gtk_tree_view_get_model(GTK_TREE_VIEW(view)); f_model = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(s_model)); model = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(f_model)); path = gnc_tree_model_owner_get_path_from_owner ( GNC_TREE_MODEL_OWNER(model), owner); if (path == NULL) { LEAVE("no path"); return; } debug_path(DEBUG, path); f_path = gtk_tree_model_filter_convert_child_path_to_path ( GTK_TREE_MODEL_FILTER (f_model), path); gtk_tree_path_free(path); if (f_path == NULL) { LEAVE("no filter path"); return; } debug_path(DEBUG, f_path); s_path = gtk_tree_model_sort_convert_child_path_to_path (GTK_TREE_MODEL_SORT (s_model), f_path); gtk_tree_path_free(f_path); if (s_path == NULL) { LEAVE("no sort path"); return; } gtk_tree_selection_select_path (selection, s_path); /* give gtk+ a chance to resize the tree view first by handling pending * configure events */ while (gtk_events_pending ()) gtk_main_iteration (); gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW(view), s_path, NULL, FALSE, 0.0, 0.0); debug_path(LEAVE, s_path); gtk_tree_path_free(s_path); }
static GtkWidget *create_window(void) { // Basic window stwidgets.startwin = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(stwidgets.startwin), apptitle); // NOTE: use global app title gtk_window_set_position(GTK_WINDOW(stwidgets.startwin), GTK_WIN_POS_CENTER); gtk_window_set_resizable(GTK_WINDOW(stwidgets.startwin), FALSE); gtk_window_set_type_hint(GTK_WINDOW(stwidgets.startwin), GDK_WINDOW_TYPE_HINT_DIALOG); // Horizontal layout of banner and controls stwidgets.hlayout = gtk_hbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(stwidgets.startwin), stwidgets.hlayout); // banner { GdkPixbuf *pixbuf = load_banner(); stwidgets.banner = gtk_image_new_from_pixbuf(pixbuf); g_object_unref((gpointer)pixbuf); } gtk_box_pack_start(GTK_BOX(stwidgets.hlayout), stwidgets.banner, FALSE, FALSE, 0); gtk_misc_set_alignment(GTK_MISC(stwidgets.banner), 0.5, 0); // Vertical layout of tab control and start+cancel buttons stwidgets.vlayout = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(stwidgets.hlayout), stwidgets.vlayout, TRUE, TRUE, 0); // Tab control stwidgets.tabs = gtk_notebook_new(); gtk_box_pack_start(GTK_BOX(stwidgets.vlayout), stwidgets.tabs, TRUE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(stwidgets.tabs), 4); // layout table of config page stwidgets.configtlayout = gtk_table_new(6, 3, FALSE); gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.configtlayout); // 3D video mode LabelText stwidgets.vmode3dlabel = gtk_label_new_with_mnemonic("_Video mode:"); gtk_misc_set_alignment(GTK_MISC(stwidgets.vmode3dlabel), 0.3, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dlabel, 0,1, 0,1, GTK_FILL, 0, 4, 0); // 3D video mode combo { GtkListStore *list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); GtkCellRenderer *cell; stwidgets.vmode3dcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list)); g_object_unref(G_OBJECT(list)); cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.vmode3dcombo), cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.vmode3dcombo), cell, "text", 0, NULL); } gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dcombo, 1,2, 0,1, GTK_EXPAND | GTK_FILL, 0, 4, 0); // Fullscreen checkbox stwidgets.displayvlayout = gtk_vbox_new(TRUE, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.displayvlayout, 2,3, 0,1, GTK_FILL, 0, 4, 0); stwidgets.fullscreencheck = gtk_check_button_new_with_mnemonic("_Fullscreen"); gtk_box_pack_start(GTK_BOX(stwidgets.displayvlayout), stwidgets.fullscreencheck, FALSE, FALSE, 0); #ifdef POLYMER // Polymer checkbox stwidgets.polymercheck = gtk_check_button_new_with_mnemonic("_Polymer"); gtk_box_pack_start(GTK_BOX(stwidgets.displayvlayout), stwidgets.polymercheck, FALSE, FALSE, 0); #endif // Input devices LabelText stwidgets.inputdevlabel = gtk_label_new_with_mnemonic("_Input devices:"); gtk_misc_set_alignment(GTK_MISC(stwidgets.inputdevlabel), 0.3, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.inputdevlabel, 0,1, 1,2, GTK_FILL, 0, 4, 0); // Input devices combo { GtkListStore *list = gtk_list_store_new(1, G_TYPE_STRING); GtkCellRenderer *cell; stwidgets.inputdevcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list)); g_object_unref(G_OBJECT(list)); cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.inputdevcombo), cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.inputdevcombo), cell, "text", 0, NULL); } gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.inputdevcombo, 1,2, 1,2, GTK_EXPAND | GTK_FILL, 0, 4, 0); // Custom mod LabelText stwidgets.custommodlabel = gtk_label_new_with_mnemonic("Custom _game:"); gtk_misc_set_alignment(GTK_MISC(stwidgets.custommodlabel), 0.3, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.custommodlabel, 0,1, 2,3, GTK_FILL, 0, 4, 7); // Custom mod combo { GtkListStore *list = gtk_list_store_new(1, G_TYPE_STRING); GtkCellRenderer *cell; stwidgets.custommodcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list)); g_object_unref(G_OBJECT(list)); cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.custommodcombo), cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.custommodcombo), cell, "text", 0, NULL); } gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.custommodcombo, 1,2, 2,3, GTK_EXPAND | GTK_FILL, 0, 4, 7); // Empty horizontal layout stwidgets.emptyhlayout = gtk_hbox_new(TRUE, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.emptyhlayout, 0,3, 3,4, 0, GTK_EXPAND | GTK_FILL, 4, 0); // Autoload checkbox stwidgets.autoloadcheck = gtk_check_button_new_with_mnemonic("_Enable \"autoload\" folder"); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.autoloadcheck, 0,3, 4,5, GTK_FILL, 0, 2, 2); // Always show config checkbox stwidgets.alwaysshowcheck = gtk_check_button_new_with_mnemonic("_Always show this window at startup"); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.alwaysshowcheck, 0,3, 5,6, GTK_FILL, 0, 2, 2); // Configuration tab stwidgets.configtab = gtk_label_new("Configuration"); gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 0), stwidgets.configtab); // Game data layout stwidgets.gamevlayout = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.gamevlayout); gtk_container_set_border_width(GTK_CONTAINER(stwidgets.gamevlayout), 4); // Game data field LabelText stwidgets.gamelabel = gtk_label_new_with_mnemonic("_Game:"); gtk_box_pack_start(GTK_BOX(stwidgets.gamevlayout), stwidgets.gamelabel, FALSE, FALSE, 0); gtk_misc_set_alignment(GTK_MISC(stwidgets.gamelabel), 0, 0.5); // Game data scrollable area stwidgets.gamescroll = gtk_scrolled_window_new(NULL, NULL); gtk_box_pack_start(GTK_BOX(stwidgets.gamevlayout), stwidgets.gamescroll, TRUE, TRUE, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(stwidgets.gamescroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(stwidgets.gamescroll), GTK_SHADOW_IN); // Game data list { GtkListStore *list = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER); GtkCellRenderer *cell; GtkTreeViewColumn *col; gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(list), 0, name_sorter, NULL, NULL); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(list), 0, GTK_SORT_ASCENDING); stwidgets.gamelist = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list)); g_object_unref(G_OBJECT(list)); cell = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes("Game", cell, "text", 0, NULL); gtk_tree_view_column_set_expand(col, TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(stwidgets.gamelist), col); col = gtk_tree_view_column_new_with_attributes("GRP file", cell, "text", 1, NULL); gtk_tree_view_column_set_min_width(col, 64); gtk_tree_view_append_column(GTK_TREE_VIEW(stwidgets.gamelist), col); } gtk_container_add(GTK_CONTAINER(stwidgets.gamescroll), stwidgets.gamelist); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(stwidgets.gamelist), FALSE); gtk_tree_view_set_enable_search(GTK_TREE_VIEW(stwidgets.gamelist), FALSE); // Game tab stwidgets.gametab = gtk_label_new("Game"); gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 1), stwidgets.gametab); // Messages scrollable area stwidgets.messagesscroll = gtk_scrolled_window_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.messagesscroll); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(stwidgets.messagesscroll), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); // Messages text area stwidgets.messagestext = gtk_text_view_new(); gtk_container_add(GTK_CONTAINER(stwidgets.messagesscroll), stwidgets.messagestext); gtk_text_view_set_editable(GTK_TEXT_VIEW(stwidgets.messagestext), FALSE); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(stwidgets.messagestext), GTK_WRAP_WORD); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(stwidgets.messagestext), FALSE); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(stwidgets.messagestext), 2); gtk_text_view_set_right_margin(GTK_TEXT_VIEW(stwidgets.messagestext), 2); // Messages tab stwidgets.messagestab = gtk_label_new("Messages"); gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 2), stwidgets.messagestab); // Dialogue box buttons layout stwidgets.buttons = gtk_hbutton_box_new(); gtk_box_pack_start(GTK_BOX(stwidgets.vlayout), stwidgets.buttons, FALSE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(stwidgets.buttons), 3); gtk_button_box_set_layout(GTK_BUTTON_BOX(stwidgets.buttons), GTK_BUTTONBOX_END); // Cancel button stwidgets.cancelbutton = gtk_button_new(); gtk_container_add(GTK_CONTAINER(stwidgets.buttons), stwidgets.cancelbutton); GTK_WIDGET_SET_FLAGS(stwidgets.cancelbutton, GTK_CAN_DEFAULT); stwidgets.cancelbuttonalign = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_container_add(GTK_CONTAINER(stwidgets.cancelbutton), stwidgets.cancelbuttonalign); stwidgets.cancelbuttonlayout = gtk_hbox_new(FALSE, 2); gtk_container_add(GTK_CONTAINER(stwidgets.cancelbuttonalign), stwidgets.cancelbuttonlayout); stwidgets.cancelbuttonicon = gtk_image_new_from_stock("gtk-cancel", GTK_ICON_SIZE_BUTTON); gtk_box_pack_start(GTK_BOX(stwidgets.cancelbuttonlayout), stwidgets.cancelbuttonicon, FALSE, FALSE, 0); stwidgets.cancelbuttonlabel = gtk_label_new_with_mnemonic("_Cancel"); gtk_box_pack_start(GTK_BOX(stwidgets.cancelbuttonlayout), stwidgets.cancelbuttonlabel, FALSE, FALSE, 0); // Start button stwidgets.startbutton = gtk_button_new(); gtk_container_add(GTK_CONTAINER(stwidgets.buttons), stwidgets.startbutton); GTK_WIDGET_SET_FLAGS(stwidgets.startbutton, GTK_CAN_DEFAULT); gtk_window_set_default(GTK_WINDOW(stwidgets.startwin), stwidgets.startbutton); stwidgets.startbuttonalign = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_container_add(GTK_CONTAINER(stwidgets.startbutton), stwidgets.startbuttonalign); stwidgets.startbuttonlayout = gtk_hbox_new(FALSE, 2); gtk_container_add(GTK_CONTAINER(stwidgets.startbuttonalign), stwidgets.startbuttonlayout); stwidgets.startbuttonicon = gtk_image_new_from_stock("gtk-execute", GTK_ICON_SIZE_BUTTON); gtk_box_pack_start(GTK_BOX(stwidgets.startbuttonlayout), stwidgets.startbuttonicon, FALSE, FALSE, 0); stwidgets.startbuttonlabel = gtk_label_new_with_mnemonic("_Start"); gtk_box_pack_start(GTK_BOX(stwidgets.startbuttonlayout), stwidgets.startbuttonlabel, FALSE, FALSE, 0); // Wire up the signals g_signal_connect((gpointer) stwidgets.startwin, "delete_event", G_CALLBACK(on_startwin_delete_event), NULL); g_signal_connect((gpointer) stwidgets.vmode3dcombo, "changed", G_CALLBACK(on_vmode3dcombo_changed), NULL); g_signal_connect((gpointer) stwidgets.fullscreencheck, "toggled", G_CALLBACK(on_fullscreencheck_toggled), NULL); #ifdef POLYMER g_signal_connect((gpointer) stwidgets.polymercheck, "toggled", G_CALLBACK(on_polymercheck_toggled), NULL); #endif g_signal_connect((gpointer) stwidgets.inputdevcombo, "changed", G_CALLBACK(on_inputdevcombo_changed), NULL); g_signal_connect((gpointer) stwidgets.custommodcombo, "changed", G_CALLBACK(on_custommodcombo_changed), NULL); g_signal_connect((gpointer) stwidgets.autoloadcheck, "toggled", G_CALLBACK(on_autoloadcheck_toggled), NULL); g_signal_connect((gpointer) stwidgets.alwaysshowcheck, "toggled", G_CALLBACK(on_alwaysshowcheck_toggled), NULL); g_signal_connect((gpointer) stwidgets.cancelbutton, "clicked", G_CALLBACK(on_cancelbutton_clicked), NULL); g_signal_connect((gpointer) stwidgets.startbutton, "clicked", G_CALLBACK(on_startbutton_clicked), NULL); { GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(stwidgets.gamelist)); gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE); g_signal_connect((gpointer) sel, "changed", G_CALLBACK(on_gamelist_selection_changed), NULL); } // Associate labels with their controls gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.vmode3dlabel), stwidgets.vmode3dcombo); gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.inputdevlabel), stwidgets.inputdevcombo); gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.custommodlabel), stwidgets.custommodcombo); gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.gamelabel), stwidgets.gamelist); return stwidgets.startwin; }
GtkWidget * pgd_layers_create_widget (PopplerDocument *document) { PgdLayersDemo *demo; GtkWidget *swindow; GtkWidget *treeview; GtkTreeModel *model; GtkCellRenderer *renderer; GtkTreeSelection *selection; GtkWidget *hpaned, *viewer; demo = g_new0 (PgdLayersDemo, 1); demo->doc = g_object_ref (document); hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); viewer = pgd_layers_create_viewer (demo); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); model = pgd_layers_create_model (document); treeview = gtk_tree_view_new_with_model (model); demo->treeview = treeview; g_object_unref (model); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), 0, "Layer", renderer, "markup", LAYERS_TITLE_COLUMN, NULL); g_object_set (G_OBJECT (renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL); g_object_set (G_OBJECT (gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), 0)), "expand", TRUE, NULL); if (GTK_IS_TREE_STORE (model)) { renderer = gtk_cell_renderer_toggle_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), 1, "Show/Hide", renderer, "active", LAYERS_VISIBILITY_COLUMN, "activatable", LAYERS_ENABLE_COLUMN, "visible", LAYERS_SHOWTOGGLE_COLUMN, NULL); g_signal_connect (renderer, "toggled", G_CALLBACK (pgd_layers_visibility_changed), (gpointer)demo); gtk_tree_view_column_set_clickable (gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), 1), TRUE); } gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)), GTK_SELECTION_NONE); gtk_container_add (GTK_CONTAINER (swindow), treeview); gtk_widget_show (treeview); gtk_paned_add1 (GTK_PANED (hpaned), swindow); gtk_widget_show (swindow); gtk_paned_add2 (GTK_PANED (hpaned), viewer); gtk_widget_show (viewer); gtk_paned_set_position (GTK_PANED (hpaned), 150); g_object_weak_ref (G_OBJECT (hpaned), (GWeakNotify)pgd_layers_free, (gpointer)demo); return hpaned; }
/** Create widget for select question in single question form. * * This will also register the corresponding setter function. * * @param fe cdebconf frontend * @param question handled question * @param question_box the container for question widgets * @param model model for the possible choices * @return the created widget, NULL if something went wrong * @see focus_path() */ static int create_select_list(struct frontend * fe, struct question * question, GtkWidget * question_box, GtkTreeModel * model) { GtkTreePath * path = NULL; GtkWidget * view; GtkWidget * scroll; GtkWidget * frame; /* check NULL! */ view = gtk_tree_view_new_with_model(model); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE /* no headers */); gtk_tree_view_set_enable_search(GTK_TREE_VIEW(view), TRUE /* enable typeahead */); gtk_tree_view_set_search_column(GTK_TREE_VIEW(view), CHOICE_MODEL_TRANSLATED_VALUE); gtk_tree_selection_set_mode( gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), GTK_SELECTION_BROWSE); if (!IS_SPECIAL_QUESTION(question)) { hide_expanders(GTK_TREE_VIEW(view)); } insert_choice_column(fe, GTK_TREE_VIEW(view)); g_signal_connect_swapped(G_OBJECT(view), "row-activated", G_CALLBACK(cdebconf_gtk_set_answer_ok), fe); if (should_expand_all(question->tag)) { gtk_tree_view_expand_all(GTK_TREE_VIEW(view)); } path = cdebconf_gtk_choice_model_get_first_selected(model); /* Select first row if there is no other default */ if (NULL == path) { path = gtk_tree_path_new_first(); } else { /* Only expand path when there was a previous selection. */ gtk_tree_view_expand_to_path(GTK_TREE_VIEW(view), path); } gtk_tree_view_set_cursor(GTK_TREE_VIEW(view), path, NULL /* don't focus a particular column */, FALSE /* don't start editing */); /* We need to focus the row *after* the widget realization, see #340007. */ g_signal_connect_after(view, "expose-event", G_CALLBACK(focus_path), path); /* path will be free'd in focus_path() */ scroll = gtk_scrolled_window_new(NULL /* create horizontal adjustement */, NULL /* create vertical adjustement */); gtk_container_add(GTK_CONTAINER(scroll), view); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); frame = gtk_frame_new(NULL); gtk_container_add(GTK_CONTAINER(frame), scroll); cdebconf_gtk_add_common_layout(fe, question, question_box, frame); gtk_widget_grab_focus(view); cdebconf_gtk_register_setter(fe, SETTER_FUNCTION(set_value_from_select), question, view); return DC_OK; }
static void PopulateForm(unsigned char pgs) { if ((pgs == ALL) || (pgs == POPULATE_VIDEO)) { int32_t mode3d, i; GtkListStore *modes3d; GtkTreeIter iter; char buf[64]; mode3d = checkvideomode(&settings.xdim3d, &settings.ydim3d, settings.bpp3d, settings.fullscreen, 1); if (mode3d < 0) { int32_t i, cd[] = { 32, 24, 16, 15, 8, 0 }; for (i=0; cd[i];) { if (cd[i] >= settings.bpp3d) i++; else break; } for (; cd[i]; i++) { mode3d = checkvideomode(&settings.xdim3d, &settings.ydim3d, cd[i], settings.fullscreen, 1); if (mode3d < 0) continue; settings.bpp3d = cd[i]; break; } } modes3d = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(stwidgets.vmode3dcombo))); gtk_list_store_clear(modes3d); for (i=0; i<validmodecnt; i++) { if (validmode[i].fs != settings.fullscreen) continue; // all modes get added to the 3D mode list Bsprintf(buf, "%d x %d %dbpp", validmode[i].xdim, validmode[i].ydim, validmode[i].bpp); gtk_list_store_append(modes3d, &iter); gtk_list_store_set(modes3d, &iter, 0,buf, 1,i, -1); if (i == mode3d) { g_signal_handlers_block_by_func(stwidgets.vmode3dcombo, on_vmode3dcombo_changed, NULL); gtk_combo_box_set_active_iter(GTK_COMBO_BOX(stwidgets.vmode3dcombo), &iter); g_signal_handlers_unblock_by_func(stwidgets.vmode3dcombo, on_vmode3dcombo_changed, NULL); } } } if ((pgs == ALL) || (pgs == POPULATE_CONFIG)) { GtkListStore *devlist, *modsdir; GtkTreeIter iter; GtkTreePath *path; char *value; unsigned char i, r = 0; const char *availabledev[] = { "Keyboard only", "Keyboard and mouse", "Keyboard and joystick", "All supported devices" }; // populate input devices combo devlist = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(stwidgets.inputdevcombo))); gtk_list_store_clear(devlist); for (i=0; i<(int32_t)G_N_ELEMENTS(availabledev); i++) { gtk_list_store_append(devlist, &iter); gtk_list_store_set(devlist, &iter, 0,availabledev[i], -1); } switch (settings.usemouse) { case 0: if (settings.usejoy) gtk_combo_box_set_active(GTK_COMBO_BOX(stwidgets.inputdevcombo), INPUT_JOYSTICK); else gtk_combo_box_set_active(GTK_COMBO_BOX(stwidgets.inputdevcombo), INPUT_KB); break; case 1: if (settings.usejoy) gtk_combo_box_set_active(GTK_COMBO_BOX(stwidgets.inputdevcombo), INPUT_ALL); else gtk_combo_box_set_active(GTK_COMBO_BOX(stwidgets.inputdevcombo), INPUT_MOUSE); break; } // populate custom mod combo modsdir = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(stwidgets.custommodcombo))); gtk_list_store_clear(modsdir); gtk_list_store_append(modsdir, &iter); gtk_list_store_set(modsdir, &iter, 0,"None", -1); r = GetModsDirNames(modsdir); for (i=0; i<=r; i++) { path = gtk_tree_path_new_from_indices(i, -1); gtk_tree_model_get_iter(GTK_TREE_MODEL(modsdir), &iter, path); gtk_tree_model_get(GTK_TREE_MODEL(modsdir), &iter, 0,&value, -1); if (Bstrcmp(settings.custommoddir, "/") == 0) { gtk_combo_box_set_active(GTK_COMBO_BOX(stwidgets.custommodcombo), NONE); settings.custommoddir = NULL; break; } if (Bstrcmp(settings.custommoddir, value) == 0) { gtk_combo_box_set_active_iter(GTK_COMBO_BOX(stwidgets.custommodcombo), &iter); break; } } // populate check buttons gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stwidgets.fullscreencheck), settings.fullscreen); #ifdef POLYMER gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stwidgets.polymercheck), settings.polymer); #endif gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stwidgets.autoloadcheck), settings.autoload); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stwidgets.alwaysshowcheck), settings.forcesetup); } if ((pgs == ALL) || (pgs == POPULATE_GAME)) { struct grpfile *fg; int32_t i; GtkListStore *list; GtkTreeIter iter; GtkTreeView *gamelist; gamelist = GTK_TREE_VIEW(stwidgets.gamelist); list = GTK_LIST_STORE(gtk_tree_view_get_model(gamelist)); gtk_list_store_clear(list); for (fg = foundgrps; fg; fg=fg->next) { for (i = 0; i<numgrpfiles; i++) if (fg->crcval == grpfiles[i].crcval) break; if (i == numgrpfiles) continue; // unrecognised grp file gtk_list_store_append(list, &iter); gtk_list_store_set(list, &iter, 0, grpfiles[i].name, 1, fg->name, 2, (gpointer)fg, -1); if (!Bstrcasecmp(fg->name, settings.selectedgrp)) { GtkTreeSelection *sel = gtk_tree_view_get_selection(gamelist); g_signal_handlers_block_by_func(sel, on_gamelist_selection_changed, NULL); gtk_tree_selection_select_iter(sel, &iter); g_signal_handlers_unblock_by_func(sel, on_gamelist_selection_changed, NULL); } } } }
static void gnc_find_account_dialog_create (GtkWidget *parent, FindAccountDialog *facc_dialog) { GtkWidget *dialog; GtkBuilder *builder; GtkTreeSelection *selection; GtkTreeViewColumn *tree_column; GtkCellRenderer *cr; ENTER(" "); builder = gtk_builder_new(); gnc_builder_add_from_file (builder, "dialog-find-account.glade", "list-store"); gnc_builder_add_from_file (builder, "dialog-find-account.glade", "Find Account Dialog"); dialog = GTK_WIDGET(gtk_builder_get_object (builder, "Find Account Dialog")); facc_dialog->dialog = dialog; facc_dialog->session = gnc_get_current_session(); /* parent */ if (parent != NULL) { facc_dialog->parent = parent; gtk_window_set_transient_for (GTK_WINDOW(dialog), GTK_WINDOW(parent)); } else facc_dialog->parent = NULL; /* Connect the radio buttons...*/ facc_dialog->radio_root = GTK_WIDGET(gtk_builder_get_object (builder, "radio-root")); facc_dialog->radio_subroot = GTK_WIDGET(gtk_builder_get_object (builder, "radio-subroot")); facc_dialog->filter_text_entry = GTK_WIDGET(gtk_builder_get_object (builder, "filter-text-entry")); facc_dialog->sub_label = GTK_WIDGET(gtk_builder_get_object (builder, "sub-label")); facc_dialog->radio_hbox = GTK_WIDGET(gtk_builder_get_object (builder, "hbox-radio")); facc_dialog->filter_button = GTK_WIDGET(gtk_builder_get_object (builder, "filter-button")); g_signal_connect (facc_dialog->filter_button, "clicked", G_CALLBACK(filter_button_cb), (gpointer)facc_dialog); facc_dialog->view = GTK_WIDGET(gtk_builder_get_object (builder, "treeview")); g_signal_connect (facc_dialog->view, "row-activated", G_CALLBACK(row_double_clicked), (gpointer)facc_dialog); /* Enable alternative line colors */ gtk_tree_view_set_rules_hint (GTK_TREE_VIEW(facc_dialog->view), TRUE); /* default to 'close' button */ gtk_dialog_set_default_response (GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(facc_dialog->view)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); /* Need to add pixbuf renderers here to get the xalign to work. */ tree_column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title (tree_column, _("Place Holder")); gtk_tree_view_append_column (GTK_TREE_VIEW(facc_dialog->view), tree_column); gtk_tree_view_column_set_alignment (tree_column, 0.5); gtk_tree_view_column_set_expand (tree_column, TRUE); cr = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start (tree_column, cr, TRUE); // connect 'active' and set 'xalign' property of the cell renderer gtk_tree_view_column_set_attributes (tree_column, cr, "stock-id", PLACE_HOLDER, NULL); gtk_cell_renderer_set_alignment (cr, 0.5, 0.5); tree_column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title (tree_column, _("Hidden")); gtk_tree_view_append_column (GTK_TREE_VIEW(facc_dialog->view), tree_column); gtk_tree_view_column_set_alignment (tree_column, 0.5); gtk_tree_view_column_set_expand (tree_column, TRUE); cr = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start (tree_column, cr, TRUE); // connect 'active' and set 'xalign' property of the cell renderer gtk_tree_view_column_set_attributes (tree_column, cr, "stock-id", HIDDEN, NULL); gtk_cell_renderer_set_alignment (cr, 0.5, 0.5); tree_column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title (tree_column, _("Not Used")); gtk_tree_view_append_column (GTK_TREE_VIEW(facc_dialog->view), tree_column); gtk_tree_view_column_set_alignment (tree_column, 0.5); gtk_tree_view_column_set_expand (tree_column, TRUE); cr = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start (tree_column, cr, TRUE); // connect 'active' and set 'xalign' property of the cell renderer gtk_tree_view_column_set_attributes (tree_column, cr, "stock-id", NOT_USED, NULL); gtk_cell_renderer_set_alignment (cr, 0.5, 0.5); tree_column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title (tree_column, _("Balance Zero")); gtk_tree_view_append_column (GTK_TREE_VIEW(facc_dialog->view), tree_column); gtk_tree_view_column_set_alignment (tree_column, 0.5); gtk_tree_view_column_set_expand (tree_column, TRUE); cr = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start (tree_column, cr, TRUE); // connect 'active' and set 'xalign' property of the cell renderer gtk_tree_view_column_set_attributes (tree_column, cr, "stock-id", BAL_ZERO, NULL); gtk_cell_renderer_set_alignment (cr, 0.5, 0.5); gtk_builder_connect_signals_full (builder, gnc_builder_connect_full_func, facc_dialog); g_object_unref (G_OBJECT(builder)); gnc_restore_window_size (GNC_PREFS_GROUP, GTK_WINDOW(facc_dialog->dialog)); if (facc_dialog->account != NULL) { const gchar *sub_label_start = _("Search from "); gchar *sub_full_name = gnc_account_get_full_name (facc_dialog->account); gchar *sub_label; sub_label = g_strconcat (sub_label_start, sub_full_name, NULL); gtk_button_set_label (GTK_BUTTON(facc_dialog->radio_subroot), sub_label); g_free (sub_full_name); g_free (sub_label); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(facc_dialog->radio_subroot), TRUE); gtk_widget_show_all (facc_dialog->radio_hbox); } else gtk_widget_hide_all (facc_dialog->radio_hbox); // Set the filter to Wildcard gtk_entry_set_text (GTK_ENTRY(facc_dialog->filter_text_entry), ""); get_account_info (facc_dialog); LEAVE(" "); }
NewStylesheetDialog::NewStylesheetDialog(const ustring & worksheet, GtkWindow *transient_parent) { myworksheet = worksheet; Shortcuts shortcuts(0); newstylesheetdialog = gtk_dialog_new(); gtk_window_set_transient_for(GTK_WINDOW(newstylesheetdialog), transient_parent); if (!worksheet.empty()) { gtk_window_set_title(GTK_WINDOW(newstylesheetdialog), _("New style")); } else { gtk_window_set_title(GTK_WINDOW(newstylesheetdialog), _("New stylesheet")); } //gtk_window_set_position(GTK_WINDOW(newstylesheetdialog), GTK_WIN_POS_CENTER_ON_PARENT); dialog_vbox1 = gtk_dialog_get_content_area (GTK_DIALOG (newstylesheetdialog)); gtk_widget_show(dialog_vbox1); hbox2 = gtk_hbox_new(FALSE, 4); gtk_widget_show(hbox2); gtk_box_pack_start(GTK_BOX(dialog_vbox1), hbox2, TRUE, TRUE, 0); vbox1 = gtk_vbox_new(FALSE, 4); gtk_widget_show(vbox1); gtk_box_pack_start(GTK_BOX(hbox2), vbox1, TRUE, TRUE, 0); if (myworksheet.empty()) { hbox1 = gtk_hbox_new(FALSE, 4); gtk_widget_show(hbox1); gtk_box_pack_start(GTK_BOX(vbox1), hbox1, TRUE, TRUE, 0); label1 = gtk_label_new(_("Name")); gtk_widget_show(label1); gtk_box_pack_start(GTK_BOX(hbox1), label1, FALSE, FALSE, 0); shortcuts.label(label1); entry1 = gtk_entry_new(); gtk_widget_show(entry1); gtk_box_pack_start(GTK_BOX(hbox1), entry1, TRUE, TRUE, 0); } ustring info; if (!myworksheet.empty()) info = _("Select one or more styles from the list"); label_info = gtk_label_new(info.c_str()); gtk_widget_show(label_info); gtk_box_pack_start(GTK_BOX(vbox1), label_info, FALSE, FALSE, 0); gtk_misc_set_alignment(GTK_MISC(label_info), 0, 0.5); GSList *radiobutton_basic_group = NULL; radiobutton_basic = gtk_radio_button_new_with_mnemonic(NULL, _("Basic")); gtk_widget_show(radiobutton_basic); gtk_box_pack_start(GTK_BOX(vbox1), radiobutton_basic, FALSE, FALSE, 0); gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_basic), radiobutton_basic_group); radiobutton_basic_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_basic)); shortcuts.button(radiobutton_basic); radiobutton_paragraph = gtk_radio_button_new_with_mnemonic(NULL, _("Basic, paragraph")); gtk_widget_show(radiobutton_paragraph); gtk_box_pack_start(GTK_BOX(vbox1), radiobutton_paragraph, FALSE, FALSE, 0); gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_paragraph), radiobutton_basic_group); radiobutton_basic_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_paragraph)); shortcuts.button(radiobutton_paragraph); radiobutton_word_note = gtk_radio_button_new_with_mnemonic(NULL, _("Basic, paragraph, word, note")); gtk_widget_show(radiobutton_word_note); gtk_box_pack_start(GTK_BOX(vbox1), radiobutton_word_note, FALSE, FALSE, 0); gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_word_note), radiobutton_basic_group); radiobutton_basic_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_word_note)); shortcuts.button(radiobutton_word_note); radiobutton_sbp = gtk_radio_button_new_with_mnemonic(NULL, _("SIL best practice")); gtk_widget_show(radiobutton_sbp); gtk_box_pack_start(GTK_BOX(vbox1), radiobutton_sbp, FALSE, FALSE, 0); gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_sbp), radiobutton_basic_group); radiobutton_basic_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_sbp)); shortcuts.button(radiobutton_sbp); radiobutton_full = gtk_radio_button_new_with_mnemonic(NULL, _("Full")); gtk_widget_show(radiobutton_full); gtk_box_pack_start(GTK_BOX(vbox1), radiobutton_full, FALSE, FALSE, 0); gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_full), radiobutton_basic_group); radiobutton_basic_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_full)); shortcuts.button(radiobutton_full); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobutton_full), true); if (!myworksheet.empty()) { expander1 = gtk_expander_new(NULL); gtk_widget_show(expander1); gtk_box_pack_start(GTK_BOX(vbox1), expander1, TRUE, TRUE, 0); label2 = gtk_label_new(_("Add non-standard style")); gtk_widget_show(label2); gtk_expander_set_label_widget(GTK_EXPANDER(expander1), label2); shortcuts.label(label2); hbox1 = gtk_hbox_new(FALSE, 4); gtk_widget_show(hbox1); gtk_container_add(GTK_CONTAINER(expander1), hbox1); label1 = gtk_label_new(_("Name")); gtk_widget_show(label1); gtk_box_pack_start(GTK_BOX(hbox1), label1, FALSE, FALSE, 0); shortcuts.label(label1); entry1 = gtk_entry_new(); gtk_widget_show(entry1); gtk_box_pack_start(GTK_BOX(hbox1), entry1, TRUE, TRUE, 0); scrolledwindow1 = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindow1); gtk_box_pack_start(GTK_BOX(hbox2), scrolledwindow1, TRUE, TRUE, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow1), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindow1), GTK_SHADOW_IN); treeview1 = gtk_tree_view_new(); gtk_widget_show(treeview1); gtk_container_add(GTK_CONTAINER(scrolledwindow1), treeview1); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview1), FALSE); store1 = gtk_list_store_new(1, G_TYPE_STRING); gtk_tree_view_set_model(GTK_TREE_VIEW(treeview1), GTK_TREE_MODEL(store1)); g_object_unref(store1); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); column1 = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview1), column1); select1 = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview1)); gtk_tree_selection_set_mode(select1, GTK_SELECTION_SINGLE); } dialog_action_area1 = gtk_dialog_get_action_area (GTK_DIALOG(newstylesheetdialog)); gtk_widget_show(dialog_action_area1); gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area1), GTK_BUTTONBOX_END); new InDialogHelp(newstylesheetdialog, NULL, &shortcuts, "file/styles/stylesheet/new"); cancelbutton1 = gtk_button_new_from_stock("gtk-cancel"); gtk_widget_show(cancelbutton1); gtk_dialog_add_action_widget(GTK_DIALOG(newstylesheetdialog), cancelbutton1, GTK_RESPONSE_CANCEL); gtk_widget_set_can_default (GTK_WIDGET (cancelbutton1), true); okbutton = gtk_button_new_from_stock("gtk-ok"); gtk_widget_show(okbutton); gtk_dialog_add_action_widget(GTK_DIALOG(newstylesheetdialog), okbutton, GTK_RESPONSE_OK); gtk_widget_set_can_default (GTK_WIDGET (okbutton), true); shortcuts.stockbutton(cancelbutton1); shortcuts.stockbutton(okbutton); shortcuts.process(); g_signal_connect((gpointer) entry1, "changed", G_CALLBACK(on_entry_changed), gpointer(this)); g_signal_connect((gpointer) radiobutton_basic, "toggled", G_CALLBACK(on_radiobutton_basic_toggled), gpointer(this)); g_signal_connect((gpointer) radiobutton_paragraph, "toggled", G_CALLBACK(on_radiobutton_paragraph_toggled), gpointer(this)); g_signal_connect((gpointer) radiobutton_word_note, "toggled", G_CALLBACK(on_radiobutton_word_note_toggled), gpointer(this)); g_signal_connect((gpointer) radiobutton_sbp, "toggled", G_CALLBACK(on_radiobutton_sbp_toggled), gpointer(this)); g_signal_connect((gpointer) radiobutton_full, "toggled", G_CALLBACK(on_radiobutton_full_toggled), gpointer(this)); g_signal_connect((gpointer) okbutton, "clicked", G_CALLBACK(on_okbutton_clicked), gpointer(this)); gtk_widget_grab_focus(entry1); gtk_widget_grab_default(okbutton); gtk_label_set_mnemonic_widget(GTK_LABEL(label1), entry1); on_entry(); on_radiobutton(); }
void clist_refresh(void) { GtkTreeView *view = GTK_TREE_VIEW(clist_wnd); GtkTreeSelection *selection; GtkTreeViewColumn *col; GtkTreeIter iter; GdkPixbuf *pix1, *pix2, *pix; GList *dirlist; gsize br, bw; gchar *utf8; int i; if(working_mode & MODE_CMD) return; // reparse folders tilp_local_selection_destroy(); tilp_dirlist_local(); selection = gtk_tree_view_get_selection(view); g_signal_handlers_block_by_func(G_OBJECT(selection), tree_selection_changed, NULL); gtk_list_store_clear(list); g_signal_handlers_unblock_by_func(G_OBJECT(selection), tree_selection_changed, NULL); // sort files for(i = 0; i < CLIST_NVCOLS; i++) { col = gtk_tree_view_get_column(view, i); gtk_tree_view_column_set_sort_indicator(col, FALSE); } switch (options.local_sort) { case SORT_BY_NAME: tilp_file_sort_by_name(); col = gtk_tree_view_get_column(view, COLUMN_NAME); gtk_tree_view_column_set_sort_indicator(col, TRUE); gtk_tree_view_column_set_sort_order(col, options.local_sort_order ? GTK_SORT_ASCENDING : GTK_SORT_DESCENDING); break; case SORT_BY_TYPE: tilp_file_sort_by_type(); col = gtk_tree_view_get_column(view, COLUMN_TYPE); gtk_tree_view_column_set_sort_indicator(col, TRUE); gtk_tree_view_column_set_sort_order(col, options.local_sort_order ? GTK_SORT_ASCENDING : GTK_SORT_DESCENDING); break; case SORT_BY_DATE: tilp_file_sort_by_date(); col = gtk_tree_view_get_column(view, COLUMN_DATE); gtk_tree_view_column_set_sort_indicator(col, TRUE); gtk_tree_view_column_set_sort_order(col, options.local_sort_order ? GTK_SORT_ASCENDING : GTK_SORT_DESCENDING); break; case SORT_BY_SIZE: tilp_file_sort_by_size(); col = gtk_tree_view_get_column(view, COLUMN_SIZE); gtk_tree_view_column_set_sort_indicator(col, TRUE); gtk_tree_view_column_set_sort_order(col, options.local_sort_order ? GTK_SORT_ASCENDING : GTK_SORT_DESCENDING); break; } pix2 = gtk_widget_render_icon(GTK_WIDGET(view), GTK_STOCK_DIRECTORY, GTK_ICON_SIZE_MENU, NULL); pix1 = gtk_widget_render_icon(GTK_WIDGET(view), GTK_STOCK_GO_UP, GTK_ICON_SIZE_MENU, NULL); for (dirlist = local.dirlist; dirlist != NULL; dirlist = dirlist->next) { FileEntry *fe = (FileEntry *) dirlist->data; gboolean b; CalcModel s = tifiles_file_get_model(fe->name); CalcModel t = options.calc_model; b = options.show_all || S_ISDIR(fe->attrib) || tifiles_file_is_tib(fe->name) || #if 0 tifiles_file_is_tigroup(fe->name) || #else tifiles_file_test(fe->name, TIFILE_TIGROUP, options.calc_model) || #endif tifiles_calc_are_compat(s, t); if(!b) continue; if (S_ISDIR(fe->attrib)) { pix = strcmp(fe->name, "..") ? pix2 : pix1; } else { char icon_name[2048]; strcpy(icon_name, tifiles_file_get_icon(fe->name)); if (!strcmp(icon_name, "")) strcpy(icon_name, "TIicon1"); strcat(icon_name, ".ico"); tilp_file_underscorize(icon_name); pix = create_pixbuf(icon_name); } // filenames are stored in the 'glib filename encoding' and GTK+ uses utf8 utf8 = g_filename_to_utf8(fe->name, -1, &br, &bw, NULL); gtk_list_store_append(list, &iter); gtk_list_store_set(list, &iter, COLUMN_NAME, utf8, COLUMN_TYPE, tilp_file_get_type(fe), COLUMN_SIZE, tilp_file_get_size(fe), COLUMN_DATE, tilp_file_get_date(fe), COLUMN_DATA, (gpointer) fe, COLUMN_ICON, pix, -1); g_free(utf8); } g_object_unref(pix1); g_object_unref(pix2); }
void gtkui_help(void) { GtkWidget *dialog, *scrolled, *treeview, *hbox, *textview, *content_area; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeIter iter; help_pair *section; DEBUG_MSG("gtkui_help"); dialog = gtk_dialog_new_with_buttons(EC_PROGRAM" Help", GTK_WINDOW (window), GTK_DIALOG_MODAL, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); gtk_window_set_default_size(GTK_WINDOW (dialog), 780, 580); #if !GTK_CHECK_VERSION(2, 22, 0) // depricated since Gtk 2.22 gtk_dialog_set_has_separator(GTK_DIALOG (dialog), TRUE); #endif gtk_container_set_border_width(GTK_CONTAINER (dialog), 5); #if GTK_CHECK_VERSION(3, 0, 0) hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6); #else hbox = gtk_hbox_new (FALSE, 6); #endif content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog)); gtk_box_pack_start(GTK_BOX(content_area), hbox, TRUE, TRUE, 0); scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(hbox), scrolled, FALSE, FALSE, 0); gtk_widget_show(scrolled); treeview = gtk_tree_view_new(); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW (treeview), FALSE); gtk_container_add(GTK_CONTAINER (scrolled), treeview); gtk_widget_show(treeview); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect(selection, "changed", G_CALLBACK (gtkui_help_selected), liststore); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Contents", renderer, "text", 0, NULL); gtk_tree_view_column_set_sort_column_id (column, 0); gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column); liststore = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER); for(section = help_list; section->title; section++) { gtk_list_store_append (liststore, &iter); gtk_list_store_set (liststore, &iter, 0, section->title, 1, section->file, -1); } gtk_tree_view_set_model(GTK_TREE_VIEW (treeview), GTK_TREE_MODEL (liststore)); /* text area */ scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(hbox), scrolled, TRUE, TRUE, 0); gtk_widget_show(scrolled); textview = gtk_text_view_new(); gtk_text_view_set_editable(GTK_TEXT_VIEW (textview), FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW (textview), FALSE); gtk_container_add(GTK_CONTAINER (scrolled), textview); gtk_widget_show(textview); textbuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW (textview)); gtk_widget_show_all(hbox); gtk_dialog_run(GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); }
static GtkDialog * create_store_view_dialog (ESource * source) { GtkWidget *dialog; GtkWidget *swin; GtkWidget *tree_view; GtkTreeSelection *selection; ScalixStoreModel *model; GtkTreeViewColumn *column; GtkCellRenderer *cell; char *text_uri; dialog = gtk_dialog_new_with_buttons (_("Select a location"), NULL, GTK_DIALOG_MODAL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_container_set_border_width (GTK_CONTAINER (dialog), 6); /* Scrolled window */ swin = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_widget_show (swin); /* ScalixStoreModel aka TreeModel */ text_uri = e_source_get_uri (source); model = scalix_store_model_new (text_uri); /* Treeview */ tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model)); g_object_set_data (G_OBJECT (dialog), "treeview", tree_view); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE); gtk_widget_show (tree_view); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (swin), tree_view); gtk_widget_add_events (tree_view, GDK_BUTTON_PRESS); column = gtk_tree_view_column_new (); /* the icon */ cell = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_set_attributes (column, cell, "pixbuf", SCM_COL_ICON, NULL); /* the text */ cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_set_attributes (column, cell, "text", SCM_COL_NAME, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column); /* Selection mode of the treeview */ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE); g_signal_connect (G_OBJECT (selection), "changed", G_CALLBACK (selection_changed), source); g_signal_connect (G_OBJECT (model), "loaded", G_CALLBACK (model_loaded), tree_view); /* Put everthing together */ gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), swin); gtk_container_set_border_width (GTK_CONTAINER (swin), 6); gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->vbox), 6); gtk_window_set_default_size (GTK_WINDOW (dialog), 420, 340); return GTK_DIALOG (dialog); }
static void OnCheatListDlg_EditClicked(GtkWidget *widget, gpointer user_data) { GtkWidget *dlg; GtkWidget *box, *scroll, *label, *descr_edit, *code_edit; GtkTreeIter iter; GtkTreeModel *model; GtkTreePath *path; gboolean selected; int index, i; char buf[8192]; char *p = buf; widget = gtk_builder_get_object(builder, "GtkCList_Cheat"); selected = gtk_tree_selection_get_selected( gtk_tree_view_get_selection(GTK_TREE_VIEW(widget)), &model, &iter); if (!selected) { return; } path = gtk_tree_model_get_path(model, &iter); index = *gtk_tree_path_get_indices(path); gtk_tree_path_free(path); dlg = gtk_dialog_new_with_buttons(_("Edit Cheat"), GTK_WINDOW(CheatListDlg), GTK_DIALOG_MODAL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL); gtk_window_set_default_size(GTK_WINDOW(dlg), 350, 350); box = GTK_WIDGET(gtk_dialog_get_content_area(GTK_DIALOG(dlg))); label = gtk_label_new(_("Cheat Description:")); gtk_box_pack_start(GTK_BOX(box), label, FALSE, FALSE, 5); gtk_widget_show(label); descr_edit = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(descr_edit), Cheats[index].Descr); gtk_box_pack_start(GTK_BOX(box), descr_edit, FALSE, FALSE, 5); gtk_widget_show(descr_edit); label = gtk_label_new(_("Cheat Code:")); gtk_box_pack_start(GTK_BOX(box), label, FALSE, FALSE, 5); gtk_widget_show(label); code_edit = gtk_text_view_new(); for (i = Cheats[index].First; i < Cheats[index].First + Cheats[index].n; i++) { sprintf(p, "%.8X %.4X\n", CheatCodes[i].Addr, CheatCodes[i].Val); p += 14; *p = '\0'; } gtk_text_buffer_set_text(gtk_text_view_get_buffer(GTK_TEXT_VIEW(code_edit)), buf, -1); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(code_edit), GTK_WRAP_CHAR); scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), code_edit); gtk_widget_show(code_edit); gtk_box_pack_start(GTK_BOX(box), scroll, TRUE, TRUE, 5); gtk_widget_show(scroll); gtk_window_set_position(GTK_WINDOW(dlg), GTK_WIN_POS_CENTER); gtk_widget_show_all(dlg); if (gtk_dialog_run(GTK_DIALOG(dlg)) == GTK_RESPONSE_ACCEPT) { GtkTextBuffer *b = gtk_text_view_get_buffer(GTK_TEXT_VIEW(code_edit)); GtkTextIter s, e; char *codetext; gtk_text_buffer_get_bounds(GTK_TEXT_BUFFER(b), &s, &e); codetext = strdup(gtk_text_buffer_get_text(GTK_TEXT_BUFFER(b), &s, &e, FALSE)); if (EditCheat(index, gtk_entry_get_text(GTK_ENTRY(descr_edit)), codetext) != 0) { SysErrorMessage(_("Error"), _("Invalid cheat code!")); } LoadCheatListItems(index); free(codetext); } gtk_widget_destroy(dlg); }
/* * delete selected rows from env variables page */ void delete_selected_rows() { /* path to select after deleting finishes */ GtkTreeRowReference *reference_to_select = NULL; /* empty row path */ GtkTreePath *empty_path = gtk_tree_row_reference_get_path(empty_row); /* get selected rows */ GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(envtree)); GList *rows = gtk_tree_selection_get_selected_rows(selection, &model); /* check whether only empty row was selected */ if (1 != gtk_tree_selection_count_selected_rows(selection) || gtk_tree_path_compare((GtkTreePath*)rows->data, empty_path)) { /* get references to the selected rows and find out what to select after deletion */ GList *references = NULL; GList *iter = rows; while (iter) { GtkTreePath *path = (GtkTreePath*)iter->data; if (!reference_to_select) { /* select upper sibling of the upper selected row that has unselected upper sibling */ GtkTreePath *sibling = gtk_tree_path_copy(path); if(gtk_tree_path_prev(sibling)) { if (!gtk_tree_selection_path_is_selected(selection, sibling)) reference_to_select = gtk_tree_row_reference_new(gtk_tree_view_get_model(GTK_TREE_VIEW(envtree)), sibling); } else if (gtk_tree_path_next(sibling), gtk_tree_path_compare(path, sibling)) reference_to_select = gtk_tree_row_reference_new(gtk_tree_view_get_model(GTK_TREE_VIEW(envtree)), sibling); } if (gtk_tree_path_compare(path, empty_path)) references = g_list_append(references, gtk_tree_row_reference_new(model, path)); iter = iter->next; } /* if all (with or without empty row) was selected - set empty row as a path to be selected after deleting */ if (!reference_to_select) reference_to_select = gtk_tree_row_reference_copy (empty_row); iter = references; while (iter) { GtkTreeRowReference *reference = (GtkTreeRowReference*)iter->data; GtkTreePath *path = gtk_tree_row_reference_get_path(reference); GtkTreeIter titer; gtk_tree_model_get_iter(model, &titer, path); gtk_list_store_remove(store, &titer); iter = iter->next; } /* set selection */ gtk_tree_selection_unselect_all(selection); GtkTreePath *path = gtk_tree_row_reference_get_path(reference_to_select); gtk_tree_selection_select_path(selection, path); gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(envtree), path, NULL, TRUE, 0.5, 0.5); /* free references list */ g_list_foreach (references, (GFunc)gtk_tree_row_reference_free, NULL); g_list_free (references); } /* free selection reference */ gtk_tree_row_reference_free(reference_to_select); /* free rows list */ g_list_foreach (rows, (GFunc)gtk_tree_path_free, NULL); g_list_free (rows); }
void xa_create_open_with_dialog(gchar *filename,gchar *filenames,int nr) { Open_with_data *data = NULL; GtkWidget *dialog_vbox1,*vbox1,*hbox1,*mime_icon,*open_text,*scrolledwindow1,*apps_treeview,*dialog_action_area1, *custom_command_expander,*hbox_expander,*browse,*cancelbutton1,*okbutton1; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeIter iter; GdkPixbuf *pixbuf; gchar *text = NULL; gchar *title; const gchar *icon_name = NULL; const gchar* const *desktop_dirs; gint x = 0; data = g_new0(Open_with_data,1); data->file_list = filenames; data->dialog1 = gtk_dialog_new (); if (nr == 1) title = _("Open With"); else title = _("Open the selected files with"); gtk_window_set_title (GTK_WINDOW (data->dialog1),title); gtk_window_set_position (GTK_WINDOW (data->dialog1), GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_modal (GTK_WINDOW (data->dialog1), TRUE); gtk_window_set_type_hint (GTK_WINDOW (data->dialog1), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_window_set_transient_for(GTK_WINDOW(data->dialog1),GTK_WINDOW(xa_main_window)); gtk_dialog_set_has_separator (GTK_DIALOG (data->dialog1),FALSE); gtk_container_set_border_width (GTK_CONTAINER (data->dialog1),5); gtk_widget_set_size_request(data->dialog1,380,380); dialog_vbox1 = GTK_DIALOG (data->dialog1)->vbox; vbox1 = gtk_vbox_new (FALSE, 5); gtk_box_pack_start (GTK_BOX (dialog_vbox1),vbox1,TRUE,TRUE,0); hbox1 = gtk_hbox_new (FALSE, 1); gtk_box_pack_start (GTK_BOX (vbox1),hbox1,FALSE,FALSE,0); if (nr == 1) { icon_name = xa_get_stock_mime_icon(filename); pixbuf = gtk_icon_theme_load_icon(icon_theme,icon_name,40,0,NULL); mime_icon = gtk_image_new_from_pixbuf(pixbuf); if (pixbuf) g_object_unref(pixbuf); gtk_box_pack_start (GTK_BOX (hbox1),mime_icon,FALSE,TRUE,0); gtk_misc_set_alignment (GTK_MISC (mime_icon),0,0); open_text = gtk_label_new(""); gtk_box_pack_start (GTK_BOX (hbox1),open_text,FALSE,FALSE,10); text = g_strdup_printf(_("Open <i>%s</i> with:"),filename); gtk_label_set_use_markup (GTK_LABEL (open_text),TRUE); gtk_label_set_markup (GTK_LABEL (open_text),text); g_free(text); } scrolledwindow1 = gtk_scrolled_window_new (NULL,NULL); gtk_box_pack_start (GTK_BOX (vbox1),scrolledwindow1,TRUE,TRUE,0); g_object_set (G_OBJECT (scrolledwindow1),"hscrollbar-policy",GTK_POLICY_AUTOMATIC,"shadow-type",GTK_SHADOW_IN,"vscrollbar-policy",GTK_POLICY_AUTOMATIC,NULL); data->apps_liststore = gtk_list_store_new (3,GDK_TYPE_PIXBUF,G_TYPE_STRING,G_TYPE_STRING); apps_treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(data->apps_liststore)); gtk_container_add (GTK_CONTAINER (scrolledwindow1),apps_treeview); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(apps_treeview),FALSE); GtkTreeSelection *sel = gtk_tree_view_get_selection( GTK_TREE_VIEW (apps_treeview)); g_signal_connect ((gpointer) sel,"changed",G_CALLBACK (xa_open_with_dialog_selection_changed),data); /* First column: icon + text */ column = gtk_tree_view_column_new(); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column,renderer, FALSE); gtk_tree_view_column_set_attributes(column,renderer,"pixbuf",0,NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start(column,renderer, TRUE); gtk_tree_view_column_set_attributes( column,renderer,"text",1,NULL); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(data->apps_liststore),1,GTK_SORT_ASCENDING); gtk_tree_view_append_column (GTK_TREE_VIEW (apps_treeview), column); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); /* Hidden column with the application executable name */ column = gtk_tree_view_column_new(); gtk_tree_view_column_set_visible(column,FALSE); gtk_tree_view_append_column (GTK_TREE_VIEW (apps_treeview), column); custom_command_expander = gtk_expander_new_with_mnemonic(_("Use a custom command:")); gtk_box_pack_start (GTK_BOX (vbox1),custom_command_expander,FALSE,FALSE,0); hbox_expander = gtk_hbox_new(FALSE,5); data->custom_command_entry = gtk_entry_new(); g_signal_connect (G_OBJECT (data->custom_command_entry),"activate",G_CALLBACK (xa_open_with_dialog_custom_entry_activated),data); browse = gtk_button_new_with_label(_("Browse")); g_signal_connect (G_OBJECT (browse),"clicked",G_CALLBACK (xa_open_with_dialog_browse_custom_command),data); gtk_box_pack_start (GTK_BOX (hbox_expander),data->custom_command_entry,TRUE,TRUE,0); gtk_box_pack_start (GTK_BOX (hbox_expander),browse,FALSE,TRUE,0); gtk_container_add(GTK_CONTAINER(custom_command_expander),hbox_expander); dialog_action_area1 = GTK_DIALOG (data->dialog1)->action_area; gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1),GTK_BUTTONBOX_END); cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel"); gtk_widget_show (cancelbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (data->dialog1),cancelbutton1,GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT); g_signal_connect_swapped (G_OBJECT (cancelbutton1),"clicked",G_CALLBACK (gtk_widget_destroy),G_OBJECT(data->dialog1)); okbutton1 = gtk_button_new_from_stock ("gtk-open"); gtk_widget_show (okbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (data->dialog1),okbutton1,GTK_RESPONSE_OK); g_signal_connect (G_OBJECT (okbutton1),"clicked",G_CALLBACK (xa_open_with_dialog_execute_command),data); GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT); gtk_widget_show_all(data->dialog1); /* Let's parse the desktop files in all the system data dirs */ desktop_dirs = g_get_system_data_dirs(); while (desktop_dirs[x]) { xa_read_desktop_directories(data->apps_liststore,desktop_dirs[x]); x++; } gtk_tree_model_get_iter_first(GTK_TREE_MODEL(data->apps_liststore),&iter); gtk_tree_selection_select_iter(gtk_tree_view_get_selection (GTK_TREE_VIEW (apps_treeview)),&iter); g_signal_connect (G_OBJECT (apps_treeview), "row-activated",G_CALLBACK(xa_open_with_dialog_row_selected),data); g_signal_connect (G_OBJECT (data->dialog1), "destroy", G_CALLBACK(xa_destroy_open_with_dialog),data); }
/* * create target page */ void tpage_init() { page = gtk_hbox_new(FALSE, 0); GtkWidget *lbox = gtk_vbox_new(FALSE, SPACING); GtkWidget *mbox = gtk_vbox_new(FALSE, SPACING); GtkWidget *rbox = gtk_vbox_new(FALSE, SPACING); GtkWidget* separator = gtk_vseparator_new(); /* right box with Load/Save buttons */ gtk_container_set_border_width(GTK_CONTAINER(rbox), SPACING); loadbtn = gtk_button_new_from_stock(GTK_STOCK_OPEN); g_signal_connect(G_OBJECT(loadbtn), "clicked", G_CALLBACK (on_load_config), (gpointer)TRUE); savebtn = gtk_button_new_from_stock(GTK_STOCK_SAVE); g_signal_connect(G_OBJECT(savebtn), "clicked", G_CALLBACK (on_save_config), NULL); clearbtn = gtk_button_new_from_stock(GTK_STOCK_CLEAR); g_signal_connect(G_OBJECT(clearbtn), "clicked", G_CALLBACK (on_clear), NULL); gtk_box_pack_start(GTK_BOX(rbox), loadbtn, FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(rbox), savebtn, FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(rbox), clearbtn, FALSE, TRUE, 0); GtkWidget *hombox = gtk_hbox_new(TRUE, 0); /* left box */ gtk_container_set_border_width(GTK_CONTAINER(lbox), SPACING); /* Target frame */ GtkWidget *frame = gtk_frame_new(_("Target")); GtkWidget *vbox = gtk_vbox_new(FALSE, 0); /* filename hbox */ GtkWidget *hbox = gtk_hbox_new(FALSE, SPACING); gtk_container_set_border_width(GTK_CONTAINER(hbox), SPACING); targetname = gtk_entry_new (); button_browse = gtk_button_new_with_label(_("Browse")); g_signal_connect(G_OBJECT(button_browse), "clicked", G_CALLBACK (on_target_browse_clicked), NULL); gtk_box_pack_start(GTK_BOX(hbox), targetname, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox), button_browse, FALSE, TRUE, 0); /* pack in the vertical box */ gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); /* debugger type hbox */ hbox = gtk_hbox_new(FALSE, SPACING); gtk_container_set_border_width(GTK_CONTAINER(hbox), SPACING); GtkWidget *label = gtk_label_new(_("Debugger:")); cmb_debugger = gtk_combo_box_new_text(); GList *modules = debug_get_modules(); GList *iter = modules; while (iter) { gtk_combo_box_append_text(GTK_COMBO_BOX(cmb_debugger), (gchar*)iter->data); iter = iter->next; } g_list_free(modules); gtk_combo_box_set_active(GTK_COMBO_BOX(cmb_debugger), 0); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), cmb_debugger, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(frame), vbox); gtk_box_pack_start(GTK_BOX(lbox), frame, FALSE, FALSE, 0); /* Arguments frame */ frame = gtk_frame_new(_("Arguments")); hbox = gtk_vbox_new(FALSE, SPACING); gtk_container_set_border_width(GTK_CONTAINER(hbox), SPACING); textview = gtk_text_view_new (); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview), GTK_WRAP_CHAR); gtk_box_pack_start(GTK_BOX(hbox), textview, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(frame), hbox); gtk_box_pack_start(GTK_BOX(lbox), frame, TRUE, TRUE, 0); /* Environment */ gtk_container_set_border_width(GTK_CONTAINER(mbox), SPACING); frame = gtk_frame_new(_("Environment variables")); hbox = gtk_hbox_new(FALSE, SPACING); gtk_container_set_border_width(GTK_CONTAINER(hbox), SPACING); store = gtk_list_store_new ( N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING); model = GTK_TREE_MODEL(store); envtree = gtk_tree_view_new_with_model (model); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(envtree), TRUE); gtk_tree_view_set_grid_lines (GTK_TREE_VIEW(envtree), GTK_TREE_VIEW_GRID_LINES_VERTICAL); g_object_set(envtree, "rules-hint", TRUE, NULL); g_signal_connect(G_OBJECT(envtree), "key-press-event", G_CALLBACK (on_envtree_keypressed), NULL); gchar *header; int char_width = get_char_width(envtree); header = _("Name"); renderer_name = gtk_cell_renderer_text_new (); g_object_set (renderer_name, "editable", TRUE, NULL); g_signal_connect (G_OBJECT (renderer_name), "edited", G_CALLBACK (on_name_changed), NULL); column_name = create_column(header, renderer_name, FALSE, get_header_string_width(header, MW_NAME, char_width), "text", NAME); gtk_tree_view_append_column (GTK_TREE_VIEW (envtree), column_name); header = _("Value"); renderer_value = gtk_cell_renderer_text_new (); column_value = create_column(header, renderer_value, TRUE, get_header_string_width(header, MW_VALUE, char_width), "text", VALUE); g_signal_connect (G_OBJECT (renderer_value), "edited", G_CALLBACK (on_value_changed), NULL); g_signal_connect (G_OBJECT (renderer_value), "editing-started", G_CALLBACK (on_value_editing_started), NULL); g_signal_connect (G_OBJECT (renderer_value), "editing-canceled", G_CALLBACK (on_value_editing_cancelled), NULL); gtk_tree_view_column_set_cell_data_func(column_value, renderer_value, on_render_value, NULL, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (envtree), column_value); /* add empty row */ add_empty_row(); /* set multiple selection */ GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(envtree)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); gtk_box_pack_start(GTK_BOX(hbox), envtree, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(frame), hbox); gtk_box_pack_start(GTK_BOX(mbox), frame, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hombox), lbox, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hombox), mbox, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(page), hombox, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(page), separator, FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(page), rbox, FALSE, TRUE, 0); /* update Load/Save config button */ tpage_on_document_activate(document_get_current()); }
/** \brief Select an existing module. * * This function creates a dialog with a list of existing modules * from /homedir/.config/Gpredict/modules/ and lets the user select one * of them. The function will return the name of the selected module * without the .mod suffix. */ static gchar *select_module() { GtkWidget *dialog; /* the dialog window */ GtkWidget *modlist; /* the treeview widget */ GtkListStore *liststore; /* the list store data structure */ GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeIter item; /* new item added to the list store */ GtkTreeSelection *selection; GtkTreeModel *selmod; GtkTreeModel *listtreemodel; GtkWidget *swin; GDir *dir = NULL; /* directory handle */ GError *error = NULL; /* error flag and info */ gchar *dirname; /* directory name */ const gchar *filename; /* file name */ gchar **buffv; guint count = 0; /* create and fill data model */ liststore = gtk_list_store_new(1, G_TYPE_STRING); /* scan for .mod files in the user config directory and add the contents of each .mod file to the list store */ dirname = get_modules_dir(); dir = g_dir_open(dirname, 0, &error); if (dir) { sat_log_log(SAT_LOG_LEVEL_DEBUG, _("%s:%s: Scanning directory %s for modules."), __FILE__, __FUNCTION__, dirname); while ((filename = g_dir_read_name(dir))) { if (g_str_has_suffix(filename, ".mod")) { /* strip extension and add to list */ buffv = g_strsplit(filename, ".mod", 0); gtk_list_store_append(liststore, &item); gtk_list_store_set(liststore, &item, 0, buffv[0], -1); g_strfreev(buffv); count++; } } } else { sat_log_log(SAT_LOG_LEVEL_ERROR, _("%s:%d: Failed to open module dir %s (%s)"), __FILE__, __LINE__, dirname, error->message); g_clear_error(&error); } g_free(dirname); g_dir_close(dir); if (count < 1) { /* tell user that there are no modules, try "New" instead */ dialog = gtk_message_dialog_new(GTK_WINDOW(app), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, _("You do not have any modules " "set up yet. Please use File->New " "in order to create a module.")); gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog); return NULL; } /* create tree view */ modlist = gtk_tree_view_new(); listtreemodel = GTK_TREE_MODEL(liststore); gtk_tree_view_set_model(GTK_TREE_VIEW(modlist), listtreemodel); g_object_unref(liststore); /* connecting row activated signal postponed so that we can attach dialog window */ swin = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); /* sort the tree by name */ gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(listtreemodel), 0, compare_func, NULL, NULL); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(listtreemodel), 0, GTK_SORT_ASCENDING); /*** FIXME: Add g_stat info? */ renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Module"), renderer, "text", 0, NULL); gtk_tree_view_insert_column(GTK_TREE_VIEW(modlist), column, -1); gtk_widget_show(modlist); /* create dialog */ dialog = gtk_dialog_new_with_buttons(_("Select a module"), GTK_WINDOW(app), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_window_set_default_size(GTK_WINDOW(dialog), -1, 200); gtk_container_add(GTK_CONTAINER(swin), modlist); gtk_widget_show(swin); gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), swin); /* double clicking in list will open clicked module */ g_signal_connect(modlist, "row-activated", G_CALLBACK(select_module_row_activated_cb), dialog); switch (gtk_dialog_run(GTK_DIALOG(dialog))) { /* user pressed OK */ case GTK_RESPONSE_OK: selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(modlist)); if (gtk_tree_selection_get_selected(selection, &selmod, &item)) { gtk_tree_model_get(selmod, &item, 0, &dirname, -1); sat_log_log(SAT_LOG_LEVEL_DEBUG, _("%s:%s: Selected module is: %s"), __FILE__, __FUNCTION__, dirname); } else { sat_log_log(SAT_LOG_LEVEL_ERROR, _("%s:%s: No selection is list of modules."), __FILE__, __FUNCTION__); dirname = NULL; } break; /* everything else is regarded as CANCEL */ default: dirname = NULL; break; } gtk_widget_destroy(dialog); return dirname; }
/** * create_bookmarks_window: * * Create a new bookmark-editing window. * @list: The NautilusBookmarkList that this window will edit. * * Return value: A pointer to the new window. **/ GtkWindow * create_bookmarks_window (NautilusBookmarkList *list, GObject *undo_manager_source) { GtkWidget *window; GtkTreeViewColumn *col; GtkCellRenderer *rend; GtkBuilder *builder; bookmarks = list; builder = gtk_builder_new (); if (!gtk_builder_add_from_file (builder, UIDIR "/nautilus-bookmarks-window.ui", NULL)) { return NULL; } window = (GtkWidget *)gtk_builder_get_object (builder, "bookmarks_dialog"); bookmark_list_widget = (GtkTreeView *)gtk_builder_get_object (builder, "bookmark_tree_view"); remove_button = (GtkWidget *)gtk_builder_get_object (builder, "bookmark_delete_button"); jump_button = (GtkWidget *)gtk_builder_get_object (builder, "bookmark_jump_button"); application = nautilus_application_dup_singleton (); set_up_close_accelerator (window); nautilus_undo_share_undo_manager (G_OBJECT (window), undo_manager_source); gtk_window_set_wmclass (GTK_WINDOW (window), "bookmarks", "Nautilus"); nautilus_bookmarks_window_restore_geometry (window); g_object_weak_ref (G_OBJECT (undo_manager_source), edit_bookmarks_dialog_reset_signals, undo_manager_source); bookmark_list_widget = GTK_TREE_VIEW (gtk_builder_get_object (builder, "bookmark_tree_view")); rend = gtk_cell_renderer_pixbuf_new (); col = gtk_tree_view_column_new_with_attributes ("Icon", rend, "gicon", BOOKMARK_LIST_COLUMN_ICON, NULL); gtk_tree_view_append_column (bookmark_list_widget, GTK_TREE_VIEW_COLUMN (col)); gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (col), NAUTILUS_ICON_SIZE_SMALLER); rend = gtk_cell_renderer_text_new (); g_object_set (rend, "ellipsize", PANGO_ELLIPSIZE_END, "ellipsize-set", TRUE, NULL); col = gtk_tree_view_column_new_with_attributes ("Icon", rend, "text", BOOKMARK_LIST_COLUMN_NAME, "style", BOOKMARK_LIST_COLUMN_STYLE, NULL); gtk_tree_view_append_column (bookmark_list_widget, GTK_TREE_VIEW_COLUMN (col)); bookmark_list_store = create_bookmark_store (); setup_empty_list (); gtk_tree_view_set_model (bookmark_list_widget, GTK_TREE_MODEL (bookmark_empty_list_store)); bookmark_selection = GTK_TREE_SELECTION (gtk_tree_view_get_selection (bookmark_list_widget)); name_field = nautilus_entry_new (); gtk_widget_show (name_field); gtk_box_pack_start (GTK_BOX (gtk_builder_get_object (builder, "bookmark_name_placeholder")), name_field, TRUE, TRUE, 0); gtk_label_set_mnemonic_widget ( GTK_LABEL (gtk_builder_get_object (builder, "bookmark_name_label")), name_field); uri_field = nautilus_entry_new (); gtk_widget_show (uri_field); gtk_box_pack_start (GTK_BOX (gtk_builder_get_object (builder, "bookmark_location_placeholder")), uri_field, TRUE, TRUE, 0); gtk_label_set_mnemonic_widget ( GTK_LABEL (gtk_builder_get_object (builder, "bookmark_location_label")), uri_field); bookmark_list_changed_signal_id = g_signal_connect (bookmarks, "changed", G_CALLBACK (on_bookmark_list_changed), NULL); row_changed_signal_id = g_signal_connect (bookmark_list_store, "row_changed", G_CALLBACK (on_row_changed), NULL); row_deleted_signal_id = g_signal_connect (bookmark_list_store, "row_deleted", G_CALLBACK (on_row_deleted), NULL); row_activated_signal_id = g_signal_connect (bookmark_list_widget, "row_activated", G_CALLBACK (on_row_activated), undo_manager_source); button_pressed_signal_id = g_signal_connect (bookmark_list_widget, "button_press_event", G_CALLBACK (on_button_pressed), NULL); key_pressed_signal_id = g_signal_connect (bookmark_list_widget, "key_press_event", G_CALLBACK (on_key_pressed), NULL); selection_changed_id = g_signal_connect (bookmark_selection, "changed", G_CALLBACK (on_selection_changed), NULL); g_signal_connect (window, "delete_event", G_CALLBACK (on_window_delete_event), NULL); g_signal_connect (window, "hide", G_CALLBACK (on_window_hide_event), NULL); g_signal_connect (window, "destroy", G_CALLBACK (on_window_destroy_event), NULL); g_signal_connect (window, "response", G_CALLBACK (nautilus_bookmarks_window_response_callback), NULL); name_field_changed_signal_id = g_signal_connect (name_field, "changed", G_CALLBACK (on_name_field_changed), NULL); g_signal_connect (name_field, "focus_out_event", G_CALLBACK (on_text_field_focus_out_event), NULL); g_signal_connect (name_field, "activate", G_CALLBACK (name_or_uri_field_activate), NULL); uri_field_changed_signal_id = g_signal_connect (uri_field, "changed", G_CALLBACK (on_uri_field_changed), NULL); g_signal_connect (uri_field, "focus_out_event", G_CALLBACK (on_text_field_focus_out_event), NULL); g_signal_connect (uri_field, "activate", G_CALLBACK (name_or_uri_field_activate), NULL); g_signal_connect (remove_button, "clicked", G_CALLBACK (on_remove_button_clicked), NULL); jump_button_signal_id = g_signal_connect (jump_button, "clicked", G_CALLBACK (on_jump_button_clicked), undo_manager_source); gtk_tree_selection_set_mode (bookmark_selection, GTK_SELECTION_BROWSE); /* Fill in list widget with bookmarks, must be after signals are wired up. */ repopulate(); g_object_unref (builder); return GTK_WINDOW (window); }
static void setup_search (GnomeControlCenter *shell) { GtkWidget *search_view, *widget; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GnomeControlCenterPrivate *priv = shell->priv; g_return_if_fail (priv->store != NULL); /* create the search filter */ priv->search_filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (priv->store), NULL); gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (priv->search_filter), (GtkTreeModelFilterVisibleFunc) model_filter_func, priv, NULL); /* set up the search view */ priv->search_view = search_view = gtk_tree_view_new (); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (search_view), FALSE); gtk_tree_view_set_model (GTK_TREE_VIEW (search_view), GTK_TREE_MODEL (priv->search_filter)); renderer = gtk_cell_renderer_pixbuf_new (); g_object_set (renderer, "follow-state", TRUE, "xpad", 15, "ypad", 10, "stock-size", GTK_ICON_SIZE_DIALOG, NULL); column = gtk_tree_view_column_new_with_attributes ("Icon", renderer, "gicon", COL_GICON, NULL); gtk_tree_view_column_set_expand (column, FALSE); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->search_view), column); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "xpad", 0, NULL); column = gtk_tree_view_column_new_with_attributes ("Name", renderer, "text", COL_NAME, NULL); gtk_tree_view_column_set_expand (column, FALSE); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->search_view), column); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "xpad", 15, NULL); column = gtk_tree_view_column_new_with_attributes ("Description", renderer, "text", COL_DESCRIPTION, NULL); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->search_view), column); priv->search_scrolled = W (priv->builder, "search-scrolled-window"); gtk_container_add (GTK_CONTAINER (priv->search_scrolled), search_view); g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->search_view)), "changed", G_CALLBACK (on_search_selection_changed), shell); /* setup the search entry widget */ widget = (GtkWidget*) gtk_builder_get_object (priv->builder, "search-entry"); priv->search_entry = widget; priv->filter_string = g_strdup (""); g_signal_connect (widget, "changed", G_CALLBACK (search_entry_changed_cb), shell); g_signal_connect (widget, "key-press-event", G_CALLBACK (search_entry_key_press_event_cb), priv); gtk_widget_show (priv->search_view); }
static void is_preferences_dialog_set_property(GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { IsPreferencesDialog *self = IS_PREFERENCES_DIALOG(object); IsPreferencesDialogPrivate *priv = self->priv; GtkWidget *scrolled_window; IsManager *manager; IsIndicatorDisplayFlags flags; switch (property_id) { case PROP_APPLICATION: priv->application = g_object_ref(g_value_get_object(value)); gtk_widget_set_sensitive(priv->display_icon_check_button, TRUE); gtk_widget_set_sensitive(priv->display_label_check_button, TRUE); gtk_widget_set_sensitive(priv->display_value_check_button, TRUE); flags = g_settings_get_int(self->priv->indicator_settings, "display-flags"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->display_icon_check_button), flags & IS_INDICATOR_DISPLAY_ICON); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->display_label_check_button), flags & IS_INDICATOR_DISPLAY_LABEL); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->display_value_check_button), flags & IS_INDICATOR_DISPLAY_VALUE); g_signal_connect(priv->display_icon_check_button, "toggled", G_CALLBACK(display_icon_toggled), self); g_signal_connect(priv->display_label_check_button, "toggled", G_CALLBACK(display_label_toggled), self); g_signal_connect(priv->display_value_check_button, "toggled", G_CALLBACK(display_value_toggled), self); g_signal_connect(priv->indicator_settings, "changed::display-flags", G_CALLBACK(settings_display_flags_changed), self); manager = is_application_get_manager(priv->application); g_signal_connect(manager, "row-activated", G_CALLBACK(manager_row_activated), self); /* control properties button sensitivity */ g_signal_connect(gtk_tree_view_get_selection(GTK_TREE_VIEW(manager)), "changed", G_CALLBACK(manager_selection_changed), self); /* set state of autostart checkbutton */ gtk_widget_set_sensitive(priv->autostart_check_button, TRUE); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->autostart_check_button), is_application_get_autostart(priv->application)); gtk_widget_set_sensitive(priv->celsius_radio_button, TRUE); gtk_widget_set_sensitive(priv->fahrenheit_radio_button, TRUE); switch (is_application_get_temperature_scale(priv->application)) { case IS_TEMPERATURE_SENSOR_SCALE_CELSIUS: gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->celsius_radio_button), TRUE); break; case IS_TEMPERATURE_SENSOR_SCALE_FAHRENHEIT: gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->fahrenheit_radio_button), TRUE); break; case IS_TEMPERATURE_SENSOR_SCALE_INVALID: case NUM_IS_TEMPERATURE_SENSOR_SCALE: default: g_assert_not_reached(); } g_signal_connect(priv->autostart_check_button, "toggled", G_CALLBACK(autostart_toggled), priv->application); g_signal_connect(priv->application, "notify::autostart", G_CALLBACK(application_notify_autostart), priv->autostart_check_button); scrolled_window = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(scrolled_window), GTK_WIDGET(manager)); gtk_widget_set_hexpand(scrolled_window, TRUE); gtk_widget_set_vexpand(scrolled_window, TRUE); gtk_grid_attach(GTK_GRID(priv->grid), scrolled_window, 0, 4, 3, 1); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); break; } }
void pevent_dialog_show () { GtkWidget *vbox, *hbox, *tbox, *wid, *bh, *th; GtkListStore *store, *hstore; GtkTreeSelection *sel; if (pevent_dialog) { mg_bring_tofront (pevent_dialog); return; } pevent_dialog = mg_create_generic_tab ("edit events", _("Edit Events"), TRUE, FALSE, pevent_dialog_close, NULL, 600, 455, &vbox, 0); wid = gtk_vpaned_new (); th = gtk_vbox_new (0, 2); bh = gtk_vbox_new (0, 2); gtk_widget_show (th); gtk_widget_show (bh); gtk_paned_pack1 (GTK_PANED (wid), th, 1, 1); gtk_paned_pack2 (GTK_PANED (wid), bh, 0, 1); gtk_box_pack_start (GTK_BOX (vbox), wid, 1, 1, 0); gtk_widget_show (wid); store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT); pevent_dialog_list = gtkutil_treeview_new (th, GTK_TREE_MODEL (store), NULL, COL_EVENT_NAME, _("Event"), COL_EVENT_TEXT, _("Text"), -1); sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (pevent_dialog_list)); g_signal_connect (G_OBJECT (sel), "changed", G_CALLBACK (pevent_dialog_select), store); pevent_dialog_twid = gtk_xtext_new (colors, 0); gtk_xtext_set_tint (GTK_XTEXT (pevent_dialog_twid), prefs.hex_text_tint_red, prefs.hex_text_tint_green, prefs.hex_text_tint_blue); gtk_xtext_set_background (GTK_XTEXT (pevent_dialog_twid), channelwin_pix, prefs.hex_text_transparent); pevent_dialog_entry = gtk_entry_new_with_max_length (255); g_signal_connect (G_OBJECT (pevent_dialog_entry), "activate", G_CALLBACK (pevent_dialog_update), pevent_dialog_twid); gtk_box_pack_start (GTK_BOX (bh), pevent_dialog_entry, 0, 0, 0); gtk_widget_show (pevent_dialog_entry); tbox = gtk_hbox_new (0, 0); gtk_container_add (GTK_CONTAINER (bh), tbox); gtk_widget_show (tbox); gtk_widget_set_usize (pevent_dialog_twid, 150, 20); gtk_container_add (GTK_CONTAINER (tbox), pevent_dialog_twid); gtk_xtext_set_font (GTK_XTEXT (pevent_dialog_twid), prefs.hex_text_font); wid = gtk_vscrollbar_new (GTK_XTEXT (pevent_dialog_twid)->adj); gtk_box_pack_start (GTK_BOX (tbox), wid, FALSE, FALSE, 0); show_and_unfocus (wid); gtk_widget_show (pevent_dialog_twid); hstore = gtk_list_store_new (2, G_TYPE_INT, G_TYPE_STRING); pevent_dialog_hlist = gtkutil_treeview_new (bh, GTK_TREE_MODEL (hstore), NULL, 0, _("$ Number"), 1, _("Description"), -1); gtk_widget_show (pevent_dialog_hlist); pevent_dialog_fill (pevent_dialog_list); gtk_widget_show (pevent_dialog_list); hbox = gtk_hbutton_box_new (); gtk_box_pack_end (GTK_BOX (vbox), hbox, 0, 0, 2); /*wid = gtk_button_new_with_label (_("Save")); gtk_box_pack_end (GTK_BOX (hbox), wid, 0, 0, 0); gtk_signal_connect (GTK_OBJECT (wid), "clicked", GTK_SIGNAL_FUNC (pevent_save_cb), NULL); gtk_widget_show (wid);*/ gtkutil_button (hbox, GTK_STOCK_SAVE_AS, NULL, pevent_save_cb, (void *) 1, _("Save As...")); gtkutil_button (hbox, GTK_STOCK_OPEN, NULL, pevent_load_cb, (void *) 0, _("Load From...")); wid = gtk_button_new_with_label (_("Test All")); gtk_box_pack_end (GTK_BOX (hbox), wid, 0, 0, 0); g_signal_connect (G_OBJECT (wid), "clicked", G_CALLBACK (pevent_test_cb), pevent_dialog_twid); gtk_widget_show (wid); wid = gtk_button_new_from_stock (GTK_STOCK_OK); gtk_box_pack_start (GTK_BOX (hbox), wid, 0, 0, 0); g_signal_connect (G_OBJECT (wid), "clicked", G_CALLBACK (pevent_ok_cb), NULL); gtk_widget_show (wid); gtk_widget_show (hbox); gtk_widget_show (pevent_dialog); }
/***************************************************************************** * Run: Gtk+ thread ***************************************************************************** * this part of the interface is in a separate thread so that we can call * gtk_main() from within it without annoying the rest of the program. *****************************************************************************/ static void Run( intf_thread_t *p_intf ) { #ifndef NEED_GTK2_MAIN /* gtk_init needs to know the command line. We don't care, so we * give it an empty one */ char *p_args[] = { "", NULL }; char **pp_args = p_args; int i_args = 1; int i_dummy; #endif playlist_t *p_playlist; GtkCellRenderer *p_renderer = NULL; GtkTreeViewColumn *p_column = NULL; GtkListStore *p_filelist = NULL; GtkListStore *p_playlist_store = NULL; #ifndef NEED_GTK2_MAIN gtk_set_locale (); msg_Dbg( p_intf, "Starting pda GTK2+ interface" ); gtk_init( &i_args, &pp_args ); #else /* Initialize Gtk+ */ msg_Dbg( p_intf, "Starting pda GTK2+ interface thread" ); gdk_threads_enter(); #endif /* Create some useful widgets that will certainly be used */ /* FIXME: magic path */ add_pixmap_directory("share"); add_pixmap_directory("/usr/share/vlc"); /* Path for pixmaps under linupy 1.4 */ add_pixmap_directory("/usr/local/share/pixmaps/vlc"); /* Path for pixmaps under linupy 2.0 */ add_pixmap_directory("/usr/share/pixmaps/vlc"); p_intf->p_sys->p_window = create_pda(); if (p_intf->p_sys->p_window == NULL) { msg_Err( p_intf, "unable to create pda interface" ); } /* Store p_intf to keep an eye on it */ gtk_object_set_data( GTK_OBJECT(p_intf->p_sys->p_window), "p_intf", p_intf ); /* Set the title of the main window */ gtk_window_set_title( GTK_WINDOW(p_intf->p_sys->p_window), VOUT_TITLE " (PDA Linux interface)"); /* Get the notebook object */ p_intf->p_sys->p_notebook = GTK_NOTEBOOK( gtk_object_get_data( GTK_OBJECT( p_intf->p_sys->p_window ), "notebook" ) ); /* Get the slider object */ p_intf->p_sys->p_slider = (GtkHScale*) lookup_widget( p_intf->p_sys->p_window, "timeSlider" ); p_intf->p_sys->p_slider_label = (GtkLabel*) lookup_widget( p_intf->p_sys->p_window, "timeLabel" ); if (p_intf->p_sys->p_slider == NULL) msg_Err( p_intf, "Time slider widget not found." ); if (p_intf->p_sys->p_slider_label == NULL) msg_Err( p_intf, "Time label widget not found." ); /* Connect the date display to the slider */ p_intf->p_sys->p_adj = gtk_range_get_adjustment( GTK_RANGE(p_intf->p_sys->p_slider) ); if (p_intf->p_sys->p_adj == NULL) msg_Err( p_intf, "Adjustment range not found." ); g_signal_connect( GTK_OBJECT( p_intf->p_sys->p_adj ), "value_changed", G_CALLBACK( E_(GtkDisplayDate) ), p_intf ); p_intf->p_sys->f_adj_oldvalue = 0; p_intf->p_sys->i_adj_oldvalue = 0; /* BEGIN OF FILEVIEW GTK_TREE_VIEW */ p_intf->p_sys->p_tvfile = NULL; p_intf->p_sys->p_tvfile = (GtkTreeView *) lookup_widget( p_intf->p_sys->p_window, "tvFileList"); if (NULL == p_intf->p_sys->p_tvfile) msg_Err(p_intf, "Error obtaining pointer to File List"); /* Insert columns 0 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 0, (gchar *) N_("Filename"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 0 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 0 ); gtk_tree_view_column_set_sort_column_id(p_column, 0); /* Insert columns 1 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 1, (gchar *) N_("Permissions"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 1 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 1 ); gtk_tree_view_column_set_sort_column_id(p_column, 1); /* Insert columns 2 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 2, (gchar *) N_("Size"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 2 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 2 ); gtk_tree_view_column_set_sort_column_id(p_column, 2); /* Insert columns 3 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 3, (gchar *) N_("Owner"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 3 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 3 ); gtk_tree_view_column_set_sort_column_id(p_column, 3); /* Insert columns 4 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 4, (gchar *) N_("Group"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 4 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 4 ); gtk_tree_view_column_set_sort_column_id(p_column, 4); /* Get new directory listing */ p_filelist = gtk_list_store_new (5, G_TYPE_STRING, /* Filename */ G_TYPE_STRING, /* permissions */ G_TYPE_UINT64, /* File size */ G_TYPE_STRING, /* Owner */ G_TYPE_STRING);/* Group */ ReadDirectory(p_intf, p_filelist, "."); gtk_tree_view_set_model(GTK_TREE_VIEW(p_intf->p_sys->p_tvfile), GTK_TREE_MODEL(p_filelist)); g_object_unref(p_filelist); /* Model will be released by GtkTreeView */ gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(p_intf->p_sys->p_tvfile)),GTK_SELECTION_MULTIPLE); /* Column properties */ gtk_tree_view_set_headers_visible(p_intf->p_sys->p_tvfile, TRUE); gtk_tree_view_columns_autosize(p_intf->p_sys->p_tvfile); gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(p_intf->p_sys->p_tvfile),TRUE); /* END OF FILEVIEW GTK_TREE_VIEW */ /* BEGIN OF PLAYLIST GTK_TREE_VIEW */ p_intf->p_sys->p_tvplaylist = NULL; p_intf->p_sys->p_tvplaylist = (GtkTreeView *) lookup_widget( p_intf->p_sys->p_window, "tvPlaylist"); if (NULL == p_intf->p_sys->p_tvplaylist) msg_Err(p_intf, "Error obtaining pointer to Play List"); /* Columns 1 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvplaylist, 0, (gchar *) N_("Filename"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvplaylist, 0 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 0 ); gtk_tree_view_column_set_sort_column_id(p_column, 0); /* Column 2 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvplaylist, 1, (gchar *) N_("Time"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvplaylist, 1 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 1 ); gtk_tree_view_column_set_sort_column_id(p_column, 1); #if 0 /* Column 3 - is a hidden column used for reliable deleting items from the underlying playlist */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvplaylist, 2, (gchar *) N_("Index"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvplaylist, 2 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 2 ); gtk_tree_view_column_set_sort_column_id(p_column, 2); #endif /* update the playlist */ p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST, FIND_ANYWHERE ); p_playlist_store = gtk_list_store_new (3, G_TYPE_STRING, /* Filename */ G_TYPE_STRING, /* Time */ G_TYPE_UINT); /* Hidden index */ PlaylistRebuildListStore(p_playlist_store, p_playlist); gtk_tree_view_set_model(GTK_TREE_VIEW(p_intf->p_sys->p_tvplaylist), GTK_TREE_MODEL(p_playlist_store)); g_object_unref(p_playlist_store); vlc_object_release(p_playlist); /* Free the playlist */ gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(p_intf->p_sys->p_tvplaylist)),GTK_SELECTION_MULTIPLE); /* Column properties */ gtk_tree_view_set_headers_visible(p_intf->p_sys->p_tvplaylist, TRUE); gtk_tree_view_columns_autosize(p_intf->p_sys->p_tvplaylist); gtk_tree_view_set_headers_clickable(p_intf->p_sys->p_tvplaylist, TRUE); /* END OF PLAYLIST GTK_TREE_VIEW */ /* Hide the Preference TAB for now. */ GtkWidget *p_preference_tab = NULL; p_preference_tab = gtk_notebook_get_nth_page(p_intf->p_sys->p_notebook,5); if (p_preference_tab != NULL) gtk_widget_hide(p_preference_tab); /* Show the control window */ gtk_widget_show( p_intf->p_sys->p_window ); #ifdef NEED_GTK2_MAIN msg_Dbg( p_intf, "Manage GTK keyboard events using threads" ); while( !p_intf->b_die ) { Manage( p_intf ); /* Sleep to avoid using all CPU - since some interfaces need to * access keyboard events, a 100ms delay is a good compromise */ gdk_threads_leave(); if (p_intf->p_libvlc->i_cpu & CPU_CAPABILITY_FPU) msleep( INTF_IDLE_SLEEP ); else msleep( 1000 ); gdk_threads_enter(); } #else msg_Dbg( p_intf, "Manage GTK keyboard events using timeouts" ); /* Sleep to avoid using all CPU - since some interfaces needs to access * keyboard events, a 1000ms delay is a good compromise */ if (p_intf->p_libvlc->i_cpu & CPU_CAPABILITY_FPU) i_dummy = gtk_timeout_add( INTF_IDLE_SLEEP / 1000, (GtkFunction)Manage, p_intf ); else i_dummy = gtk_timeout_add( 1000, (GtkFunction)Manage, p_intf ); /* Enter Gtk mode */ gtk_main(); /* Remove the timeout */ gtk_timeout_remove( i_dummy ); #endif gtk_object_destroy( GTK_OBJECT(p_intf->p_sys->p_window) ); #ifdef NEED_GTK2_MAIN gdk_threads_leave(); #endif }
static void thunar_uca_chooser_init (ThunarUcaChooser *uca_chooser) { GtkTreeViewColumn *column; GtkTreeSelection *selection; GtkCellRenderer *renderer; ThunarUcaModel *uca_model; GtkWidget *image; GtkWidget *label; GtkWidget *hbox; GtkWidget *swin; GtkWidget *vbox; /* configure the dialog window */ gtk_dialog_add_button (GTK_DIALOG (uca_chooser), GTK_STOCK_HELP, GTK_RESPONSE_HELP); gtk_dialog_add_button (GTK_DIALOG (uca_chooser), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); gtk_dialog_set_default_response (GTK_DIALOG (uca_chooser), GTK_RESPONSE_CLOSE); gtk_dialog_set_has_separator (GTK_DIALOG (uca_chooser), FALSE); gtk_window_set_default_size (GTK_WINDOW (uca_chooser), 500, 350); gtk_window_set_destroy_with_parent (GTK_WINDOW (uca_chooser), TRUE); gtk_window_set_title (GTK_WINDOW (uca_chooser), _("Custom Actions")); hbox = gtk_hbox_new (FALSE, 3); gtk_container_set_border_width (GTK_CONTAINER (hbox), 6); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (uca_chooser)->vbox), hbox, FALSE, TRUE, 0); gtk_widget_show (hbox); image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DND); gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0); gtk_widget_show (image); label = gtk_label_new (_("You can configure custom actions that will appear in the\n" "file managers context menus for certain kinds of files.")); gtk_misc_set_alignment (GTK_MISC (label), 0.0f, 0.5f); gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); hbox = gtk_hbox_new (FALSE, 3); gtk_container_set_border_width (GTK_CONTAINER (hbox), 6); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (uca_chooser)->vbox), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); swin = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (swin), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (hbox), swin, TRUE, TRUE, 0); gtk_widget_show (swin); uca_chooser->treeview = gtk_tree_view_new (); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (uca_chooser->treeview), FALSE); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (uca_chooser->treeview), TRUE); gtk_container_add (GTK_CONTAINER (swin), uca_chooser->treeview); g_signal_connect_swapped (G_OBJECT (uca_chooser->treeview), "row-activated", G_CALLBACK (thunar_uca_chooser_edit_clicked), uca_chooser); gtk_widget_show (uca_chooser->treeview); uca_model = thunar_uca_model_get_default (); gtk_tree_view_set_model (GTK_TREE_VIEW (uca_chooser->treeview), GTK_TREE_MODEL (uca_model)); g_object_unref (G_OBJECT (uca_model)); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_column_set_resizable (column, FALSE); gtk_tree_view_append_column (GTK_TREE_VIEW (uca_chooser->treeview), column); renderer = g_object_new (GTK_TYPE_CELL_RENDERER_PIXBUF, "stock-size", GTK_ICON_SIZE_DND, "xpad", 2, "ypad", 2, NULL); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "icon-name", THUNAR_UCA_MODEL_COLUMN_ICON, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "markup", THUNAR_UCA_MODEL_COLUMN_STOCK_LABEL, NULL); vbox = gtk_vbox_new (FALSE, 3); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); uca_chooser->add_button = gtk_button_new (); gtk_widget_set_tooltip_text (uca_chooser->add_button, _("Add a new custom action.")); gtk_box_pack_start (GTK_BOX (vbox), uca_chooser->add_button, FALSE, FALSE, 0); g_signal_connect_swapped (G_OBJECT (uca_chooser->add_button), "clicked", G_CALLBACK (thunar_uca_chooser_add_clicked), uca_chooser); gtk_widget_show (uca_chooser->add_button); image = gtk_image_new_from_stock (GTK_STOCK_ADD, GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (uca_chooser->add_button), image); gtk_widget_show (image); uca_chooser->edit_button = gtk_button_new (); gtk_widget_set_tooltip_text (uca_chooser->edit_button, _("Edit the currently selected action.")); gtk_box_pack_start (GTK_BOX (vbox), uca_chooser->edit_button, FALSE, FALSE, 0); g_signal_connect_swapped (G_OBJECT (uca_chooser->edit_button), "clicked", G_CALLBACK (thunar_uca_chooser_edit_clicked), uca_chooser); gtk_widget_show (uca_chooser->edit_button); image = gtk_image_new_from_stock (GTK_STOCK_EDIT, GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (uca_chooser->edit_button), image); gtk_widget_show (image); uca_chooser->delete_button = gtk_button_new (); gtk_widget_set_tooltip_text (uca_chooser->delete_button, _("Delete the currently selected action.")); gtk_box_pack_start (GTK_BOX (vbox), uca_chooser->delete_button, FALSE, FALSE, 0); g_signal_connect_swapped (G_OBJECT (uca_chooser->delete_button), "clicked", G_CALLBACK (thunar_uca_chooser_delete_clicked), uca_chooser); gtk_widget_show (uca_chooser->delete_button); image = gtk_image_new_from_stock (GTK_STOCK_DELETE, GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (uca_chooser->delete_button), image); gtk_widget_show (image); uca_chooser->up_button = gtk_button_new (); gtk_widget_set_tooltip_text (uca_chooser->up_button, _("Move the currently selected action up by one row.")); gtk_box_pack_start (GTK_BOX (vbox), uca_chooser->up_button, FALSE, FALSE, 0); g_signal_connect_swapped (G_OBJECT (uca_chooser->up_button), "clicked", G_CALLBACK (thunar_uca_chooser_up_clicked), uca_chooser); gtk_widget_show (uca_chooser->up_button); image = gtk_image_new_from_stock (GTK_STOCK_GO_UP, GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (uca_chooser->up_button), image); gtk_widget_show (image); uca_chooser->down_button = gtk_button_new (); gtk_widget_set_tooltip_text (uca_chooser->down_button, _("Move the currently selected action down by one row.")); gtk_box_pack_start (GTK_BOX (vbox), uca_chooser->down_button, FALSE, FALSE, 0); g_signal_connect_swapped (G_OBJECT (uca_chooser->down_button), "clicked", G_CALLBACK (thunar_uca_chooser_down_clicked), uca_chooser); gtk_widget_show (uca_chooser->down_button); image = gtk_image_new_from_stock (GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (uca_chooser->down_button), image); gtk_widget_show (image); /* configure the tree view selection after the buttons have been created */ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (uca_chooser->treeview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect_swapped (G_OBJECT (selection), "changed", G_CALLBACK (thunar_uca_chooser_selection_changed), uca_chooser); thunar_uca_chooser_selection_changed (uca_chooser, selection); }
static void ifopts_edit_cb(GtkWidget *w, gpointer data _U_) { GtkWidget *ifopts_edit_dlg, *cur_scr_win, *main_hb, *main_tb, *cur_opts_fr, *ed_opts_fr, *main_vb, *if_descr_lb, *if_hide_lb, *bbox, *ok_bt, *cancel_bt, *help_bt; GtkListStore *list_store; GtkWidget *list; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkTreeView *list_view; GtkTreeSelection *selection; int row = 0; GtkWidget *caller = gtk_widget_get_toplevel(w); /* Has an edit dialog box already been opened for that top-level widget? */ ifopts_edit_dlg = g_object_get_data(G_OBJECT(caller), IFOPTS_DIALOG_PTR_KEY); if (ifopts_edit_dlg != NULL) { /* Yes. Just re-activate that dialog box. */ reactivate_window(ifopts_edit_dlg); return; } /* create a new dialog */ ifopts_edit_dlg = dlg_conf_window_new("Wireshark: Preferences: Interface Options"); gtk_window_set_default_size(GTK_WINDOW(ifopts_edit_dlg), 1000, 440); main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 1, FALSE); gtk_container_set_border_width(GTK_CONTAINER(main_vb), 5); gtk_container_add(GTK_CONTAINER(ifopts_edit_dlg), main_vb); gtk_widget_show(main_vb); /* create current options frame */ cur_opts_fr = gtk_frame_new("Interfaces"); gtk_container_add(GTK_CONTAINER(main_vb), cur_opts_fr); gtk_widget_show(cur_opts_fr); /* create a scrolled window to pack the current options TreeView widget into */ cur_scr_win = scrolled_window_new(NULL, NULL); gtk_container_set_border_width(GTK_CONTAINER(cur_scr_win), 3); gtk_container_add(GTK_CONTAINER(cur_opts_fr), cur_scr_win); gtk_widget_show(cur_scr_win); /* * Create current options TreeView. */ list_store = gtk_list_store_new(N_COLUMN, /* Total number of columns XXX */ G_TYPE_STRING, /* Device */ G_TYPE_STRING, /* Description */ #ifdef HAVE_PCAP_CREATE G_TYPE_BOOLEAN, /* Monitor mode */ #endif G_TYPE_STRING, /* Default link-layer */ G_TYPE_STRING, /* Comment */ G_TYPE_BOOLEAN, /* Hide? */ G_TYPE_INT); /* Dlt */ list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store)); list_view = GTK_TREE_VIEW(list); /* The view now holds a reference. We can get rid of our own reference */ g_object_unref (G_OBJECT (list_store)); /* * Create the first column packet, associating the "text" attribute of the * cell_renderer to the first column of the model */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Device", renderer, "text", DEVICE_COLUMN, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); #ifdef _WIN32 gtk_tree_view_column_set_min_width(column, 230); #else gtk_tree_view_column_set_min_width(column, 70); #endif /* Add the column to the view. */ gtk_tree_view_append_column (list_view, column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Description", renderer, "text", DESC_COLUMN, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 260); /* Add the column to the view. */ gtk_tree_view_append_column (list_view, column); #ifdef HAVE_PCAP_CREATE /* * XXX - for some reason, this doesn't show up. */ renderer = gtk_cell_renderer_toggle_new (); column = gtk_tree_view_column_new_with_attributes ("Default to monitor mode", renderer, "active", DEF_MONITOR_MODE_COLUMN, NULL); gtk_tree_view_column_set_resizable(column, FALSE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); /* Add the column to the view. */ gtk_tree_view_append_column (list_view, column); #endif renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Default link-layer", renderer, "text", DEF_LINK_LAYER_COLUMN, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 230); /* Add the column to the view. */ gtk_tree_view_append_column (list_view, column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Comment", renderer, "text", COMMENT_COLUMN, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 100); /* Add the column to the view. */ gtk_tree_view_append_column (list_view, column); renderer = gtk_cell_renderer_toggle_new (); column = gtk_tree_view_column_new_with_attributes ("Hide?", renderer, "active", HIDE_COLUMN, NULL); gtk_tree_view_column_set_resizable(column, FALSE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); /* Add the column to the view. */ gtk_tree_view_append_column (list_view, column); #if 0 /* Don't show the DLT column */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("DLT", renderer, "text", DLT_COLUMN, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 40); /* Add the column to the view. */ gtk_tree_view_append_column (list_view, column); #endif /* Setup the selection handler */ selection = gtk_tree_view_get_selection(list_view); gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE); cur_list = list; gtk_container_add(GTK_CONTAINER(cur_scr_win), cur_list); if_selection = selection; g_signal_connect (G_OBJECT (selection), "changed", /* select_row */ G_CALLBACK (ifopts_edit_ifsel_cb), NULL); gtk_widget_show(cur_list); /* add interface names to cell */ ifopts_if_liststore_add(); /* create edit options frame */ ed_opts_fr = gtk_frame_new("Properties"); gtk_box_pack_start(GTK_BOX(main_vb), ed_opts_fr, FALSE, FALSE, 0); gtk_widget_show(ed_opts_fr); main_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5, TRUE); gtk_container_set_border_width(GTK_CONTAINER(main_hb), 3); gtk_container_add(GTK_CONTAINER(ed_opts_fr), main_hb); gtk_widget_show(main_hb); /* table to hold description text entry and hide button */ main_tb = gtk_table_new(IFOPTS_TABLE_ROWS, 4, FALSE); gtk_box_pack_start(GTK_BOX(main_hb), main_tb, TRUE, FALSE, 10); gtk_table_set_row_spacings(GTK_TABLE(main_tb), 10); gtk_table_set_col_spacings(GTK_TABLE(main_tb), 10); gtk_widget_show(main_tb); if_dev_lb = gtk_label_new("Device:"); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_dev_lb, 0, 1, row, row+1); gtk_misc_set_alignment(GTK_MISC(if_dev_lb), 1.0f, 0.5f); gtk_widget_show(if_dev_lb); if_dev_lb = gtk_label_new(""); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_dev_lb, 1, 2, row, row+1); gtk_misc_set_alignment(GTK_MISC(if_dev_lb), 0.0f, 0.5f); gtk_widget_show(if_dev_lb); row++; if_name_lb = gtk_label_new("Description:"); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_name_lb, 0, 1, row, row+1); gtk_misc_set_alignment(GTK_MISC(if_name_lb), 1.0f, 0.5f); gtk_widget_show(if_name_lb); if_name_lb = gtk_label_new(""); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_name_lb, 1, 2, row, row+1); gtk_misc_set_alignment(GTK_MISC(if_name_lb), 0.0f, 0.5f); gtk_widget_show(if_name_lb); row++; #ifdef HAVE_PCAP_CREATE /* create "monitor mode" label and button */ if_monitor_lb = gtk_label_new("Monitor mode:"); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_monitor_lb, 0, 1, row, row+1); gtk_misc_set_alignment(GTK_MISC(if_monitor_lb), 1.0f, 0.5f); gtk_widget_show(if_monitor_lb); if_monitor_cb = gtk_check_button_new(); g_signal_connect(if_monitor_cb, "toggled", G_CALLBACK(ifopts_edit_monitor_changed_cb), cur_list); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_monitor_cb, 1, 2, row, row+1); gtk_widget_show(if_monitor_cb); row++; #endif if_linktype_lb = gtk_label_new("Default link-layer header type:"); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_linktype_lb, 0, 1, row, row+1); gtk_misc_set_alignment(GTK_MISC(if_linktype_lb), 1.0f, 0.5f); gtk_widget_show(if_linktype_lb); if_linktype_cb = gtk_combo_box_text_new(); num_linktypes = 0; interfaces_info_nochange = FALSE; g_signal_connect(if_linktype_cb, "changed", G_CALLBACK(ifopts_edit_linktype_changed_cb), cur_list); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_linktype_cb, 1, 2, row, row+1); gtk_widget_show(if_linktype_cb); row++; /* create interface description label and text entry */ if_descr_lb = gtk_label_new("Comment:"); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_descr_lb, 0, 1, row, row+1); gtk_misc_set_alignment(GTK_MISC(if_descr_lb), 1.0f, 0.5f); gtk_widget_show(if_descr_lb); if_descr_te = gtk_entry_new(); g_signal_connect(if_descr_te, "changed", G_CALLBACK(ifopts_edit_descr_changed_cb), cur_list); gtk_entry_set_max_length(GTK_ENTRY(if_descr_te), IFOPTS_MAX_DESCR_LEN); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_descr_te, 1, 2, row, row+1); gtk_widget_show(if_descr_te); row++; /* create "hide interface" label and button */ if_hide_lb = gtk_label_new("Hide interface?:"); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_hide_lb, 0, 1, row, row+1); gtk_misc_set_alignment(GTK_MISC(if_hide_lb), 1.0f, 0.5f); gtk_widget_show(if_hide_lb); if_hide_cb = gtk_check_button_new(); g_signal_connect(if_hide_cb, "toggled", G_CALLBACK(ifopts_edit_hide_changed_cb), cur_list); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_hide_cb, 1, 2, row, row+1); gtk_widget_show(if_hide_cb); row++; /* button row: OK and Cancel buttons */ bbox = dlg_button_row_new(GTK_STOCK_OK, GTK_STOCK_CANCEL, GTK_STOCK_HELP, NULL); gtk_box_pack_start(GTK_BOX(main_vb), bbox, FALSE, FALSE, 0); gtk_widget_show(bbox); ok_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_OK); gtk_widget_set_tooltip_text(ok_bt, "Save changes and exit dialog"); g_signal_connect(ok_bt, "clicked", G_CALLBACK(ifopts_edit_ok_cb), ifopts_edit_dlg); cancel_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CANCEL); gtk_widget_set_tooltip_text(cancel_bt, "Cancel and exit dialog"); window_set_cancel_button(ifopts_edit_dlg, cancel_bt, window_cancel_button_cb); help_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_HELP); g_signal_connect(help_bt, "clicked", G_CALLBACK(topic_cb), (gpointer)HELP_CAPTURE_INTERFACE_OPTIONS_DIALOG); gtk_widget_set_tooltip_text (help_bt, "Show topic specific help"); gtk_widget_grab_default(ok_bt); g_signal_connect(ifopts_edit_dlg, "delete_event", G_CALLBACK(window_delete_event_cb), NULL); /* Call a handler when we're destroyed, so we can inform our caller, if any, that we've been destroyed. */ g_signal_connect(ifopts_edit_dlg, "destroy", G_CALLBACK(ifopts_edit_destroy_cb), NULL); /* Set the key for the new dialog to point to our caller. */ g_object_set_data(G_OBJECT(ifopts_edit_dlg), IFOPTS_CALLER_PTR_KEY, caller); /* Set the key for the caller to point to us */ g_object_set_data(G_OBJECT(caller), IFOPTS_DIALOG_PTR_KEY, ifopts_edit_dlg); gtk_widget_show(ifopts_edit_dlg); /* triggers ifopts_edit_ifsel_cb() with the */ /* "interfaces" TreeView first row selected */ window_present(ifopts_edit_dlg); }
void init_right_tree(void) { GtkTreeView *view = GTK_TREE_VIEW(tree2_w); GtkCellRenderer *renderer; GtkTreeSelection *sel; GtkTreeViewColumn *column; gint i; gtk_tree_view_set_model(view, model2); gtk_tree_view_set_headers_visible(view, TRUE); gtk_tree_view_set_rules_hint(view, TRUE); column = gtk_tree_view_column_new(); gtk_tree_view_append_column(view, column); gtk_tree_view_column_set_title(column, _("Options")); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE); gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer, "pixbuf", COL_PIXBUF, "visible", COL_PIXVIS, NULL); renderer = gtk_cell_renderer_toggle_new(); gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE); gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer, "active", COL_BTNACT, "inconsistent", COL_BTNINC, "visible", COL_BTNVIS, "radio", COL_BTNRAD, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE); gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer, "text", COL_OPTION, "foreground-gdk", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Name"), renderer, "text", COL_NAME, "foreground-gdk", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, "N", renderer, "text", COL_NO, "foreground-gdk", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, "M", renderer, "text", COL_MOD, "foreground-gdk", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, "Y", renderer, "text", COL_YES, "foreground-gdk", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Value"), renderer, "text", COL_VALUE, "editable", COL_EDIT, "foreground-gdk", COL_COLOR, NULL); g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK(renderer_edited), NULL); column = gtk_tree_view_get_column(view, COL_NAME); gtk_tree_view_column_set_visible(column, show_name); column = gtk_tree_view_get_column(view, COL_NO); gtk_tree_view_column_set_visible(column, show_range); column = gtk_tree_view_get_column(view, COL_MOD); gtk_tree_view_column_set_visible(column, show_range); column = gtk_tree_view_get_column(view, COL_YES); gtk_tree_view_column_set_visible(column, show_range); column = gtk_tree_view_get_column(view, COL_VALUE); gtk_tree_view_column_set_visible(column, show_value); if (resizeable) { for (i = 0; i < COL_VALUE; i++) { column = gtk_tree_view_get_column(view, i); gtk_tree_view_column_set_resizable(column, TRUE); } } sel = gtk_tree_view_get_selection(view); gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE); }
gint display_action_dbox(gchar *target) { GtkBuilder *builder; GError* error = NULL; GtkWidget *dbox; GtkWidget *data; GtkTreeIter iter; GList *sel; int button = 0; gint result; gboolean empty = TRUE; // update folder listing (if supported) if (!(ticalcs_calc_features(calc_handle) & FTS_SILENT) ) return BUTTON1; else { if(remote.var_tree == NULL) { if (tilp_dirlist_remote()) return BUTTON1; ctree_refresh(); labels_refresh(); } } // box creation builder = gtk_builder_new(); if (!gtk_builder_add_from_file (builder, tilp_paths_build_builder("action.ui"), &error)) { g_warning (_("Couldn't load builder file: %s\n"), error->message); g_error_free (error); return 0; // THIS RETURNS ! } gtk_builder_connect_signals(builder, NULL); dbox = GTK_WIDGET (gtk_builder_get_object (builder, "action_dbox")); gtk_dialog_set_alternative_button_order(GTK_DIALOG(dbox), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL,-1); clist = data = GTK_WIDGET (gtk_builder_get_object (builder, "treeview1")); // clist creation create_clist(data); // fill model for (sel = local.selection1; sel != NULL; sel = sel->next) { FileEntry *f = (FileEntry *)sel->data; FileContent *c = (FileContent *)f->content1; if(f->content1 == NULL) // file can't be loaded continue; // we have now 1 VarEntry per FileContent { VarEntry *v = c->entries[0]; VarEntry *w; gchar **row_text = g_malloc0(5 * sizeof(gchar *)); char *trans; char full_name[260]; // modify attr or folder if target is specified if(strcmp(target, "")) { if(!strcmp(target, "<FLASH>")) { v->attr = ATTRB_ARCHIVED; } else { strcpy(v->folder, target); } } // search for matching var tifiles_build_fullname(options.calc_model, full_name, v->folder, v->name); trans = ticonv_varname_to_utf8(options.calc_model, (const char *)full_name, v->type); w = ticalcs_dirlist_ve_exist(remote.var_tree, v); if (w == NULL) continue; if(w->attr == ATTRB_LOCKED || w->attr == ATTRB_ARCHIVED) v->action = ACT_SKIP; else v->action = ACT_SKIP; //don't overwrite as default behaviour // file contains an already existing var: add it to the window row_text[0] = trans; row_text[1] = g_strdup(tifiles_attribute_to_string(v->attr)); row_text[2] = g_strdup(f->name); row_text[3] = g_strdup(action2string(v->action)); tilp_vars_translate(row_text[0]); gtk_list_store_append(list, &iter); gtk_list_store_set(list, &iter, COLUMN_VAR, row_text[0], COLUMN_ATTR, row_text[1], COLUMN_FILE, row_text[2], COLUMN_ACTION, row_text[3], COLUMN_DATA_F, (gpointer)f, COLUMN_DATA_V, (gpointer)v, -1); g_strfreev(row_text); empty = FALSE; } } if (empty == TRUE) { button = BUTTON1; // skip box as ok goto out_clean; } // select all vars { GtkTreeView *view = GTK_TREE_VIEW(clist); GtkTreeSelection *sel2; sel2 = gtk_tree_view_get_selection(view); gtk_tree_selection_select_all(sel2); } // box running gtk_dialog_set_default_response(GTK_DIALOG(dbox), GTK_RESPONSE_CANCEL); result = gtk_dialog_run(GTK_DIALOG(dbox)); switch (result) { case GTK_RESPONSE_OK: button = BUTTON1; break; case GTK_RESPONSE_CANCEL: button = BUTTON2; default: button = BUTTON2; break; } out_clean: gtk_widget_destroy(dbox); return button; }