void gs_page_install_app (GsPage *page, GsApp *app, GsShellInteraction interaction, GCancellable *cancellable) { GsPagePrivate *priv = gs_page_get_instance_private (page); GsPageHelper *helper; /* probably non-free */ if (gs_app_get_state (app) == AS_APP_STATE_UNAVAILABLE) { GtkResponseType response; response = gs_app_notify_unavailable (app, gs_shell_get_window (priv->shell)); if (response != GTK_RESPONSE_OK) return; } helper = g_slice_new0 (GsPageHelper); helper->action = GS_PLUGIN_ACTION_INSTALL; helper->app = g_object_ref (app); helper->page = g_object_ref (page); helper->cancellable = g_object_ref (cancellable); helper->interaction = interaction; /* need to purchase first */ if (gs_app_get_state (app) == AS_APP_STATE_PURCHASABLE) { GtkWidget *dialog; g_autofree gchar *title = NULL; g_autofree gchar *message = NULL; g_autofree gchar *price_text = NULL; /* TRANSLATORS: this is a prompt message, and '%s' is an * application summary, e.g. 'GNOME Clocks' */ title = g_strdup_printf (_("Are you sure you want to purchase %s?"), gs_app_get_name (app)); price_text = gs_price_to_string (gs_app_get_price (app)); /* TRANSLATORS: longer dialog text */ message = g_strdup_printf (_("%s will be installed, and you will " "be charged %s."), gs_app_get_name (app), price_text); dialog = gtk_message_dialog_new (gs_shell_get_window (priv->shell), GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_CANCEL, "%s", title); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "%s", message); /* TRANSLATORS: this is button text to purchase the application */ gtk_dialog_add_button (GTK_DIALOG (dialog), _("Purchase"), GTK_RESPONSE_OK); /* handle this async */ g_signal_connect (dialog, "response", G_CALLBACK (gs_page_install_purchase_response_cb), helper); gs_shell_modal_dialog_present (priv->shell, GTK_DIALOG (dialog)); } else { g_autoptr(GsPluginJob) plugin_job = NULL; plugin_job = gs_plugin_job_newv (helper->action, "interactive", TRUE, "app", helper->app, NULL); gs_plugin_loader_job_process_async (priv->plugin_loader, plugin_job, helper->cancellable, gs_page_app_installed_cb, helper); } }
extern void change_grid_popup(GtkAction *action, gpointer user_data) { GtkWidget *table = gtk_table_new(1, 2, FALSE); GtkWidget *label; GtkObject *adjustment; GtkWidget *width_sb, *hori_sb, *vert_sb; int width = working_sview_config.grid_x_width, hori = working_sview_config.grid_hori, vert = working_sview_config.grid_vert; GtkWidget *popup = gtk_dialog_new_with_buttons( "Grid Properties", GTK_WINDOW (user_data), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, NULL); GError *error = NULL; int response = 0; char *temp = NULL; label = gtk_dialog_add_button(GTK_DIALOG(popup), GTK_STOCK_OK, GTK_RESPONSE_OK); gtk_window_set_default(GTK_WINDOW(popup), label); gtk_dialog_add_button(GTK_DIALOG(popup), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox), table, FALSE, FALSE, 0); label = gtk_label_new("Nodes in row "); adjustment = gtk_adjustment_new(working_sview_config.grid_x_width, 1, 1000, 1, 60, 0); width_sb = gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1, 0); gtk_container_set_border_width(GTK_CONTAINER(table), 10); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1); gtk_table_attach_defaults(GTK_TABLE(table), width_sb, 1, 2, 0, 1); label = gtk_label_new("Nodes before horizontal break "); adjustment = gtk_adjustment_new(working_sview_config.grid_hori, 1, 1000, 1, 60, 0); hori_sb = gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1, 0); gtk_container_set_border_width(GTK_CONTAINER(table), 10); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 1, 2); gtk_table_attach_defaults(GTK_TABLE(table), hori_sb, 1, 2, 1, 2); label = gtk_label_new("Nodes before vertical break "); adjustment = gtk_adjustment_new(working_sview_config.grid_vert, 1, 1000, 1, 60, 0); vert_sb = gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1, 0); gtk_container_set_border_width(GTK_CONTAINER(table), 10); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 2, 3); gtk_table_attach_defaults(GTK_TABLE(table), vert_sb, 1, 2, 2, 3); /*TODO * do we care about this? label = gtk_label_new("Topology ordered "); adjustment = gtk_adjustment_new(working_sview_config.grid_topological, 1, 1000, 1, 60, 0); GtkWidget *gtbtton = gtk_check_button_new (); gtk_container_set_border_width(GTK_CONTAINER(table), 10); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 3, 4); gtk_table_attach_defaults(GTK_TABLE(table), gtbtton, 1, 2, 3, 4); gtk_toggle_button_set_active (>btton, working_sview_config.grid_topological); */ gtk_widget_show_all(popup); response = gtk_dialog_run (GTK_DIALOG(popup)); if (response == GTK_RESPONSE_OK) { working_sview_config.grid_x_width = gtk_spin_button_get_value_as_int( GTK_SPIN_BUTTON(width_sb)); working_sview_config.grid_hori = gtk_spin_button_get_value_as_int( GTK_SPIN_BUTTON(hori_sb)); working_sview_config.grid_vert = gtk_spin_button_get_value_as_int( GTK_SPIN_BUTTON(vert_sb)); memcpy(&default_sview_config, &working_sview_config, sizeof(sview_config_t)); if ((width == working_sview_config.grid_x_width) && (hori == working_sview_config.grid_hori) && (vert == working_sview_config.grid_vert)) { temp = g_strdup_printf("Grid: Nothing changed."); } else if (working_sview_config.grid_topological) { temp = g_strdup_printf("Grid: Invalid mode .." " switch to non-topology " "order first."); } else { bool refresh = 0; temp = g_strdup_printf( "Grid set to %d nodes breaks " "at %d H and %d V.", working_sview_config.grid_x_width, working_sview_config.grid_hori, working_sview_config.grid_vert); /* If the old width was wider than the * current we need to remake the list so the * table gets set up correctly, so destroy it * here and it will be remade in get_system_stats(). */ if ((width > working_sview_config.grid_x_width) && grid_button_list) { list_destroy(grid_button_list); grid_button_list = NULL; refresh = 1; } get_system_stats(main_grid_table); if (refresh) refresh_main(NULL, NULL); } gtk_statusbar_pop(GTK_STATUSBAR(main_statusbar), STATUS_REFRESH); response = gtk_statusbar_push(GTK_STATUSBAR(main_statusbar), STATUS_REFRESH, temp); g_free(temp); if (!sview_thread_new(_refresh_thr, GINT_TO_POINTER(response), FALSE, &error)) { g_printerr ("Failed to create refresh thread: %s\n", error->message); } } gtk_widget_destroy(popup); return; }
static void component_dialog_show () { GtkWidget *sw; GtkWidget *event_view; GtkListStore *ls; GtkCellRenderer *rendt; GtkTreeViewColumn *col; GtkTreeSelection *sel; if (component_dialog != NULL) { gtk_window_present(GTK_WINDOW(component_dialog)); return; } component_dialog = gtk_dialog_new_with_buttons (_("Select a widget type"), NULL, GTK_DIALOG_NO_SEPARATOR, NULL); choose_button = gtk_dialog_add_button (GTK_DIALOG(component_dialog), _("Create widget"), AP_RESPONSE_CHOOSE); gtk_dialog_add_button (GTK_DIALOG(component_dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); gtk_widget_set_sensitive (choose_button, FALSE); sw = gtk_scrolled_window_new (NULL,NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX(GTK_DIALOG(component_dialog)->vbox), sw, TRUE, TRUE, 0); ls = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE(ls), 0, GTK_SORT_ASCENDING); update_component_list (ls); event_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL(ls)); g_signal_connect(G_OBJECT(event_view), "row-activated", G_CALLBACK(component_row_activate_cb), event_view); sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (event_view)); rendt = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes (_("Widget type"), rendt, "markup", 0, NULL); #if GTK_CHECK_VERSION(2,6,0) gtk_tree_view_column_set_expand (col, TRUE); g_object_set(rendt, "ellipsize", PANGO_ELLIPSIZE_END, NULL); #endif gtk_tree_view_append_column (GTK_TREE_VIEW(event_view), col); gtk_tree_view_column_set_sort_column_id (col, 0); g_object_unref (G_OBJECT(ls)); gtk_container_add (GTK_CONTAINER(sw), event_view); g_signal_connect (G_OBJECT (sel), "changed", G_CALLBACK (component_sel_cb), NULL); g_signal_connect(G_OBJECT(component_dialog), "response", G_CALLBACK(component_response_cb), sel); gtk_window_set_default_size(GTK_WINDOW(component_dialog), 550, 430); gtk_widget_show_all(component_dialog); }
void configure_gpio(GtkWidget *parent) { gpio_restore_state(); GtkWidget *dialog=gtk_dialog_new_with_buttons("Configure GPIO",GTK_WINDOW(parent),GTK_DIALOG_DESTROY_WITH_PARENT,NULL,NULL); GtkWidget *content=gtk_dialog_get_content_area(GTK_DIALOG(dialog)); GtkWidget *grid=gtk_grid_new(); //gtk_grid_set_column_homogeneous(GTK_GRID(grid),TRUE); gtk_grid_set_row_homogeneous(GTK_GRID(grid),TRUE); GtkWidget *b_enable_vfo_encoder=gtk_check_button_new_with_label("Enable VFO"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (b_enable_vfo_encoder), ENABLE_VFO_ENCODER); gtk_widget_show(b_enable_vfo_encoder); gtk_grid_attach(GTK_GRID(grid),b_enable_vfo_encoder,0,0,1,1); GtkWidget *vfo_a_label=gtk_label_new("GPIO A:"); gtk_widget_show(vfo_a_label); gtk_grid_attach(GTK_GRID(grid),vfo_a_label,1,0,1,1); GtkWidget *vfo_a=gtk_spin_button_new_with_range (0.0,100.0,1.0); gtk_spin_button_set_value (GTK_SPIN_BUTTON(vfo_a),VFO_ENCODER_A); gtk_widget_show(vfo_a); gtk_grid_attach(GTK_GRID(grid),vfo_a,2,0,1,1); GtkWidget *vfo_b_label=gtk_label_new("GPIO B:"); gtk_widget_show(vfo_b_label); gtk_grid_attach(GTK_GRID(grid),vfo_b_label,3,0,1,1); GtkWidget *vfo_b=gtk_spin_button_new_with_range (0.0,100.0,1.0); gtk_spin_button_set_value (GTK_SPIN_BUTTON(vfo_b),VFO_ENCODER_B); gtk_widget_show(vfo_b); gtk_grid_attach(GTK_GRID(grid),vfo_b,4,0,1,1); GtkWidget *b_enable_vfo_pullup=gtk_check_button_new_with_label("Enable Pull-up"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (b_enable_vfo_pullup), ENABLE_VFO_PULLUP); gtk_widget_show(b_enable_vfo_pullup); gtk_grid_attach(GTK_GRID(grid),b_enable_vfo_pullup,5,0,1,1); GtkWidget *b_enable_af_encoder=gtk_check_button_new_with_label("Enable AF"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (b_enable_af_encoder), ENABLE_AF_ENCODER); gtk_widget_show(b_enable_af_encoder); gtk_grid_attach(GTK_GRID(grid),b_enable_af_encoder,0,1,1,1); GtkWidget *af_a_label=gtk_label_new("GPIO A:"); gtk_widget_show(af_a_label); gtk_grid_attach(GTK_GRID(grid),af_a_label,1,1,1,1); GtkWidget *af_a=gtk_spin_button_new_with_range (0.0,100.0,1.0); gtk_spin_button_set_value (GTK_SPIN_BUTTON(af_a),AF_ENCODER_A); gtk_widget_show(af_a); gtk_grid_attach(GTK_GRID(grid),af_a,2,1,1,1); GtkWidget *af_b_label=gtk_label_new("GPIO B:"); gtk_widget_show(af_b_label); gtk_grid_attach(GTK_GRID(grid),af_b_label,3,1,1,1); GtkWidget *af_b=gtk_spin_button_new_with_range (0.0,100.0,1.0); gtk_spin_button_set_value (GTK_SPIN_BUTTON(af_b),AF_ENCODER_B); gtk_widget_show(af_b); gtk_grid_attach(GTK_GRID(grid),af_b,4,1,1,1); GtkWidget *b_enable_af_pullup=gtk_check_button_new_with_label("Enable Pull-up"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (b_enable_af_pullup), ENABLE_AF_PULLUP); gtk_widget_show(b_enable_af_pullup); gtk_grid_attach(GTK_GRID(grid),b_enable_af_pullup,5,1,1,1); GtkWidget *b_enable_rf_encoder=gtk_check_button_new_with_label("Enable RF"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (b_enable_rf_encoder), ENABLE_RF_ENCODER); gtk_widget_show(b_enable_rf_encoder); gtk_grid_attach(GTK_GRID(grid),b_enable_rf_encoder,0,2,1,1); GtkWidget *rf_a_label=gtk_label_new("GPIO A:"); gtk_widget_show(rf_a_label); gtk_grid_attach(GTK_GRID(grid),rf_a_label,1,2,1,1); GtkWidget *rf_a=gtk_spin_button_new_with_range (0.0,100.0,1.0); gtk_spin_button_set_value (GTK_SPIN_BUTTON(rf_a),RF_ENCODER_A); gtk_widget_show(rf_a); gtk_grid_attach(GTK_GRID(grid),rf_a,2,2,1,1); GtkWidget *rf_b_label=gtk_label_new("GPIO B:"); gtk_widget_show(rf_b_label); gtk_grid_attach(GTK_GRID(grid),rf_b_label,3,2,1,1); GtkWidget *rf_b=gtk_spin_button_new_with_range (0.0,100.0,1.0); gtk_spin_button_set_value (GTK_SPIN_BUTTON(rf_b),RF_ENCODER_B); gtk_widget_show(rf_b); gtk_grid_attach(GTK_GRID(grid),rf_b,4,2,1,1); GtkWidget *b_enable_rf_pullup=gtk_check_button_new_with_label("Enable Pull-up"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (b_enable_rf_pullup), ENABLE_RF_PULLUP); gtk_widget_show(b_enable_rf_pullup); gtk_grid_attach(GTK_GRID(grid),b_enable_rf_pullup,5,2,1,1); GtkWidget *b_enable_agc_encoder=gtk_check_button_new_with_label("Enable AGC"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (b_enable_agc_encoder), ENABLE_AGC_ENCODER); gtk_widget_show(b_enable_agc_encoder); gtk_grid_attach(GTK_GRID(grid),b_enable_agc_encoder,0,3,1,1); GtkWidget *agc_a_label=gtk_label_new("GPIO A:"); gtk_widget_show(agc_a_label); gtk_grid_attach(GTK_GRID(grid),agc_a_label,1,3,1,1); GtkWidget *agc_a=gtk_spin_button_new_with_range (0.0,100.0,1.0); gtk_spin_button_set_value (GTK_SPIN_BUTTON(agc_a),AGC_ENCODER_A); gtk_widget_show(agc_a); gtk_grid_attach(GTK_GRID(grid),agc_a,2,3,1,1); GtkWidget *agc_b_label=gtk_label_new("GPIO B:"); gtk_widget_show(agc_b_label); gtk_grid_attach(GTK_GRID(grid),agc_b_label,3,3,1,1); GtkWidget *agc_b=gtk_spin_button_new_with_range (0.0,100.0,1.0); gtk_spin_button_set_value (GTK_SPIN_BUTTON(agc_b),AGC_ENCODER_B); gtk_widget_show(agc_b); gtk_grid_attach(GTK_GRID(grid),agc_b,4,3,1,1); GtkWidget *b_enable_agc_pullup=gtk_check_button_new_with_label("Enable Pull-up"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (b_enable_agc_pullup), ENABLE_AGC_PULLUP); gtk_widget_show(b_enable_agc_pullup); gtk_grid_attach(GTK_GRID(grid),b_enable_agc_pullup,5,3,1,1); GtkWidget *b_enable_band=gtk_check_button_new_with_label("Enable Band"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (b_enable_band), ENABLE_BAND_BUTTON); gtk_widget_show(b_enable_band); gtk_grid_attach(GTK_GRID(grid),b_enable_band,0,4,1,1); GtkWidget *band_label=gtk_label_new("GPIO:"); gtk_widget_show(band_label); gtk_grid_attach(GTK_GRID(grid),band_label,1,4,1,1); GtkWidget *band=gtk_spin_button_new_with_range (0.0,100.0,1.0); gtk_spin_button_set_value (GTK_SPIN_BUTTON(band),BAND_BUTTON); gtk_widget_show(band); gtk_grid_attach(GTK_GRID(grid),band,2,4,1,1); GtkWidget *b_enable_mode=gtk_check_button_new_with_label("Enable Mode"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (b_enable_mode), ENABLE_MODE_BUTTON); gtk_widget_show(b_enable_mode); gtk_grid_attach(GTK_GRID(grid),b_enable_mode,0,5,1,1); GtkWidget *mode_label=gtk_label_new("GPIO:"); gtk_widget_show(mode_label); gtk_grid_attach(GTK_GRID(grid),mode_label,1,5,1,1); GtkWidget *mode=gtk_spin_button_new_with_range (0.0,100.0,1.0); gtk_spin_button_set_value (GTK_SPIN_BUTTON(mode),MODE_BUTTON); gtk_widget_show(mode); gtk_grid_attach(GTK_GRID(grid),mode,2,5,1,1); GtkWidget *b_enable_filter=gtk_check_button_new_with_label("Enable Filter"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (b_enable_filter), ENABLE_FILTER_BUTTON); gtk_widget_show(b_enable_filter); gtk_grid_attach(GTK_GRID(grid),b_enable_filter,0,6,1,1); GtkWidget *filter_label=gtk_label_new("GPIO:"); gtk_widget_show(filter_label); gtk_grid_attach(GTK_GRID(grid),filter_label,1,6,1,1); GtkWidget *filter=gtk_spin_button_new_with_range (0.0,100.0,1.0); gtk_spin_button_set_value (GTK_SPIN_BUTTON(filter),FILTER_BUTTON); gtk_widget_show(filter); gtk_grid_attach(GTK_GRID(grid),filter,2,6,1,1); GtkWidget *b_enable_noise=gtk_check_button_new_with_label("Enable Noise"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (b_enable_noise), ENABLE_NOISE_BUTTON); gtk_widget_show(b_enable_noise); gtk_grid_attach(GTK_GRID(grid),b_enable_noise,0,7,1,1); GtkWidget *noise_label=gtk_label_new("GPIO:"); gtk_widget_show(noise_label); gtk_grid_attach(GTK_GRID(grid),noise_label,1,7,1,1); GtkWidget *noise=gtk_spin_button_new_with_range (0.0,100.0,1.0); gtk_spin_button_set_value (GTK_SPIN_BUTTON(noise),NOISE_BUTTON); gtk_widget_show(noise); gtk_grid_attach(GTK_GRID(grid),noise,2,7,1,1); GtkWidget *b_enable_agc=gtk_check_button_new_with_label("Enable AGC"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (b_enable_agc), ENABLE_AGC_BUTTON); gtk_widget_show(b_enable_agc); gtk_grid_attach(GTK_GRID(grid),b_enable_agc,0,8,1,1); GtkWidget *agc_label=gtk_label_new("GPIO:"); gtk_widget_show(agc_label); gtk_grid_attach(GTK_GRID(grid),agc_label,1,8,1,1); GtkWidget *agc=gtk_spin_button_new_with_range (0.0,100.0,1.0); gtk_spin_button_set_value (GTK_SPIN_BUTTON(agc),AGC_BUTTON); gtk_widget_show(agc); gtk_grid_attach(GTK_GRID(grid),agc,2,8,1,1); GtkWidget *b_enable_mox=gtk_check_button_new_with_label("Enable MOX"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (b_enable_mox), ENABLE_MOX_BUTTON); gtk_widget_show(b_enable_mox); gtk_grid_attach(GTK_GRID(grid),b_enable_mox,0,9,1,1); GtkWidget *mox_label=gtk_label_new("GPIO:"); gtk_widget_show(mox_label); gtk_grid_attach(GTK_GRID(grid),mox_label,1,9,1,1); GtkWidget *mox=gtk_spin_button_new_with_range (0.0,100.0,1.0); gtk_spin_button_set_value (GTK_SPIN_BUTTON(mox),MOX_BUTTON); gtk_widget_show(mox); gtk_grid_attach(GTK_GRID(grid),mox,2,9,1,1); GtkWidget *b_enable_function=gtk_check_button_new_with_label("Enable Function"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (b_enable_function), ENABLE_FUNCTION_BUTTON); gtk_widget_show(b_enable_function); gtk_grid_attach(GTK_GRID(grid),b_enable_function,0,10,1,1); GtkWidget *function_label=gtk_label_new("GPIO:"); gtk_widget_show(function_label); gtk_grid_attach(GTK_GRID(grid),function_label,1,10,1,1); GtkWidget *function=gtk_spin_button_new_with_range (0.0,100.0,1.0); gtk_spin_button_set_value (GTK_SPIN_BUTTON(function),FUNCTION_BUTTON); gtk_widget_show(function); gtk_grid_attach(GTK_GRID(grid),function,2,10,1,1); gtk_container_add(GTK_CONTAINER(content),grid); gtk_container_add(GTK_CONTAINER(content),grid); GtkWidget *close_button=gtk_dialog_add_button(GTK_DIALOG(dialog),"Close",GTK_RESPONSE_OK); //gtk_widget_override_font(close_button, pango_font_description_from_string("Arial 20")); gtk_widget_show_all(dialog); int result=gtk_dialog_run(GTK_DIALOG(dialog)); ENABLE_VFO_ENCODER=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(b_enable_vfo_encoder))?1:0; VFO_ENCODER_A=gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(vfo_a)); VFO_ENCODER_B=gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(vfo_b)); ENABLE_VFO_PULLUP=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(b_enable_vfo_pullup))?1:0; ENABLE_AF_ENCODER=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(b_enable_af_encoder))?1:0; AF_ENCODER_A=gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(af_a)); AF_ENCODER_B=gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(af_b)); ENABLE_AF_PULLUP=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(b_enable_af_pullup))?1:0; ENABLE_RF_ENCODER=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(b_enable_rf_encoder))?1:0; RF_ENCODER_A=gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(rf_a)); RF_ENCODER_B=gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(rf_b)); ENABLE_RF_PULLUP=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(b_enable_rf_pullup))?1:0; ENABLE_AGC_ENCODER=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(b_enable_agc_encoder))?1:0; AGC_ENCODER_A=gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(agc_a)); AGC_ENCODER_B=gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(agc_b)); ENABLE_AGC_PULLUP=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(b_enable_agc_pullup))?1:0; ENABLE_BAND_BUTTON=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(b_enable_band))?1:0; BAND_BUTTON=gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(band)); ENABLE_MODE_BUTTON=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(b_enable_mode))?1:0; MODE_BUTTON=gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(mode)); ENABLE_FILTER_BUTTON=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(b_enable_filter))?1:0; FILTER_BUTTON=gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(filter)); ENABLE_NOISE_BUTTON=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(b_enable_noise))?1:0; NOISE_BUTTON=gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(noise)); ENABLE_AGC_BUTTON=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(b_enable_agc))?1:0; AGC_BUTTON=gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(agc)); ENABLE_MOX_BUTTON=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(b_enable_mox))?1:0; MOX_BUTTON=gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(mox)); ENABLE_FUNCTION_BUTTON=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(b_enable_function))?1:0; FUNCTION_BUTTON=gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(function)); gtk_widget_destroy(dialog); gpio_save_state(); }
extern void create_search_popup(GtkAction *action, gpointer user_data) { GtkWidget *popup = gtk_dialog_new_with_buttons( "Search", GTK_WINDOW(user_data), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, NULL); int response = 0; GtkWidget *label = NULL; GtkWidget *entry = NULL; GtkTreeModel *model = NULL; GtkTreeIter iter; const gchar *name = gtk_action_get_name(action); sview_search_info_t sview_search_info; sview_search_info.gchar_data = NULL; sview_search_info.int_data = NO_VAL; sview_search_info.int_data2 = NO_VAL; label = gtk_dialog_add_button(GTK_DIALOG(popup), GTK_STOCK_OK, GTK_RESPONSE_OK); gtk_window_set_default(GTK_WINDOW(popup), label); gtk_dialog_add_button(GTK_DIALOG(popup), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); if (!strcmp(name, "jobid")) { sview_search_info.search_type = SEARCH_JOB_ID; entry = create_entry(); label = gtk_label_new("Which job id?"); } else if (!strcmp(name, "user_jobs")) { sview_search_info.search_type = SEARCH_JOB_USER; entry = create_entry(); label = gtk_label_new("Which user?"); } else if (!strcmp(name, "state_jobs")) { display_data_t pulldown_display_data[] = { {G_TYPE_NONE, JOB_PENDING, "Pending", TRUE, -1}, {G_TYPE_NONE, JOB_CONFIGURING, "Configuring", TRUE, -1}, {G_TYPE_NONE, JOB_RUNNING, "Running", TRUE, -1}, {G_TYPE_NONE, JOB_SUSPENDED, "Suspended", TRUE, -1}, {G_TYPE_NONE, JOB_COMPLETE, "Complete", TRUE, -1}, {G_TYPE_NONE, JOB_CANCELLED, "Cancelled", TRUE, -1}, {G_TYPE_NONE, JOB_FAILED, "Failed", TRUE, -1}, {G_TYPE_NONE, JOB_TIMEOUT, "Timeout", TRUE, -1}, {G_TYPE_NONE, JOB_NODE_FAIL, "Node Failure", TRUE, -1}, {G_TYPE_NONE, JOB_PREEMPTED, "Preempted", TRUE, -1}, {G_TYPE_NONE, -1, NULL, FALSE, -1} }; sview_search_info.search_type = SEARCH_JOB_STATE; entry = create_pulldown_combo(pulldown_display_data, JOB_END); label = gtk_label_new("Which state?"); } else if (!strcmp(name, "partition_name")) { sview_search_info.search_type = SEARCH_PARTITION_NAME; entry = create_entry(); label = gtk_label_new("Which partition"); } else if (!strcmp(name, "partition_state")) { display_data_t pulldown_display_data[] = { {G_TYPE_NONE, PARTITION_UP, "Up", TRUE, -1}, {G_TYPE_NONE, PARTITION_DOWN, "Down", TRUE, -1}, {G_TYPE_NONE, PARTITION_INACTIVE, "Inactive", TRUE, -1}, {G_TYPE_NONE, PARTITION_DRAIN, "Drain", TRUE, -1}, {G_TYPE_NONE, -1, NULL, FALSE, -1} }; sview_search_info.search_type = SEARCH_PARTITION_STATE; entry = create_pulldown_combo(pulldown_display_data, 5); label = gtk_label_new("Which state?"); } else if (!strcmp(name, "node_name")) { sview_search_info.search_type = SEARCH_NODE_NAME; entry = create_entry(); if (cluster_flags & CLUSTER_FLAG_BG) label = gtk_label_new("Which Midplane(s)?\n" "(ranged or comma separated)"); else label = gtk_label_new("Which node(s)?\n" "(ranged or comma separated)"); } else if (!strcmp(name, "node_state")) { display_data_t pulldown_display_data[] = { {G_TYPE_NONE, NODE_STATE_DOWN, "Down", TRUE, -1}, {G_TYPE_NONE, NODE_STATE_ALLOCATED | NODE_STATE_DRAIN, "Draining", TRUE, -1}, {G_TYPE_NONE, NODE_STATE_IDLE | NODE_STATE_DRAIN, "Drained", TRUE, -1}, {G_TYPE_NONE, NODE_STATE_IDLE, "Idle", TRUE, -1}, {G_TYPE_NONE, NODE_STATE_ALLOCATED, "Allocated", TRUE, -1}, {G_TYPE_NONE, NODE_STATE_ERROR, "Error", TRUE, -1}, {G_TYPE_NONE, NODE_STATE_MIXED, "Mixed", TRUE, -1}, {G_TYPE_NONE, NODE_STATE_COMPLETING, "Completing", TRUE, -1}, {G_TYPE_NONE, NODE_STATE_UNKNOWN, "Unknown", TRUE, -1}, {G_TYPE_NONE, -1, NULL, FALSE, -1} }; sview_search_info.search_type = SEARCH_NODE_STATE; entry = create_pulldown_combo(pulldown_display_data, PAGE_CNT); label = gtk_label_new("Which state?"); } else if ((cluster_flags & CLUSTER_FLAG_BG) && !strcmp(name, "bg_block_name")) { sview_search_info.search_type = SEARCH_BLOCK_NAME; entry = create_entry(); label = gtk_label_new("Which block?"); } else if ((cluster_flags & CLUSTER_FLAG_BG) && !strcmp(name, "bg_block_size")) { sview_search_info.search_type = SEARCH_BLOCK_SIZE; entry = create_entry(); label = gtk_label_new("Which block size?"); } else if (!strcmp(name, "bg_block_state")) { display_data_t pulldown_display_data[] = { {G_TYPE_NONE, BG_BLOCK_NAV, "Nav", TRUE, -1}, {G_TYPE_NONE, BG_BLOCK_FREE, "Free", TRUE, -1}, {G_TYPE_NONE, BG_BLOCK_BUSY, NULL, TRUE, -1}, {G_TYPE_NONE, BG_BLOCK_BOOTING, "Booting", TRUE, -1}, {G_TYPE_NONE, BG_BLOCK_REBOOTING, NULL, TRUE, -1}, {G_TYPE_NONE, BG_BLOCK_INITED, "Inited", TRUE, -1}, {G_TYPE_NONE, BG_BLOCK_ALLOCATED, NULL, TRUE, -1}, {G_TYPE_NONE, BG_BLOCK_TERM, "Terminating", TRUE, -1}, {G_TYPE_NONE, BG_BLOCK_ERROR_FLAG, "Error", TRUE, -1}, {G_TYPE_NONE, -1, NULL, FALSE, -1} }; display_data_t *display_data = pulldown_display_data; while (display_data++) { if (display_data->id == -1) break; if (cluster_flags & CLUSTER_FLAG_BGL) { switch(display_data->id) { case BG_BLOCK_BUSY: display_data->name = "Busy"; break; } } else if (cluster_flags & CLUSTER_FLAG_BGP){ switch(display_data->id) { case BG_BLOCK_REBOOTING: display_data->name = "Rebooting"; break; } } else { switch(display_data->id) { case BG_BLOCK_ALLOCATED: display_data->name = "Allocated"; break; } } } sview_search_info.search_type = SEARCH_BLOCK_STATE; entry = create_pulldown_combo(pulldown_display_data, PAGE_CNT); label = gtk_label_new("Which state?"); } else if (!strcmp(name, "reservation_name")) { sview_search_info.search_type = SEARCH_RESERVATION_NAME; entry = create_entry(); label = gtk_label_new("Which reservation"); } else { sview_search_info.search_type = 0; goto end_it; } gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox), label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox), entry, FALSE, FALSE, 0); gtk_widget_show_all(popup); response = gtk_dialog_run (GTK_DIALOG(popup)); if (response == GTK_RESPONSE_OK) { if (!sview_search_info.search_type) goto end_it; switch(sview_search_info.search_type) { case SEARCH_BLOCK_STATE: case SEARCH_JOB_STATE: case SEARCH_NODE_STATE: case SEARCH_PARTITION_STATE: if (!gtk_combo_box_get_active_iter(GTK_COMBO_BOX(entry), &iter)) { g_print("nothing selected\n"); return; } model = gtk_combo_box_get_model(GTK_COMBO_BOX(entry)); if (!model) { g_print("nothing selected\n"); return; } gtk_tree_model_get(model, &iter, 0, &sview_search_info.int_data, -1); break; case SEARCH_JOB_ID: case SEARCH_JOB_USER: case SEARCH_BLOCK_NAME: case SEARCH_BLOCK_SIZE: case SEARCH_PARTITION_NAME: case SEARCH_NODE_NAME: case SEARCH_RESERVATION_NAME: sview_search_info.gchar_data = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry))); break; default: break; } _search_entry(&sview_search_info); } end_it: gtk_widget_destroy(popup); return; }
int geanypg_encrypt_selection_dialog(encrypt_data * ed, gpgme_key_t ** selected, int * sign) { GtkWidget * dialog = gtk_dialog_new(); unsigned long idx, sidx, capacity; int response; GtkWidget * contentarea, * listview, * scrollwin, * combobox; GtkTreeIter iter; listdata data; gboolean active; GtkListStore * list; *sign = 0; list = geanypg_makelist(ed->key_array, ed->nkeys, 0); listview = geanypg_listview(list, &data); scrollwin = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrollwin), listview); gtk_widget_set_size_request(scrollwin, 500, 160); combobox = geanypg_combobox(geanypg_makelist(ed->skey_array, ed->nskeys, 1)); contentarea = gtk_dialog_get_content_area(GTK_DIALOG(dialog)); gtk_box_pack_start(GTK_BOX(contentarea), gtk_label_new(_("Please select any recipients")), FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(contentarea), scrollwin, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(contentarea), gtk_label_new(_("Sign the message as:")), FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(contentarea), combobox, FALSE, FALSE, 0); /* add ok and cancel buttons */ gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_OK, GTK_RESPONSE_OK); gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); gtk_window_set_title(GTK_WINDOW(dialog), _("Select recipients")); gtk_widget_show_all(dialog); /* make sure dialog is destroyed when user responds */ response = gtk_dialog_run(GTK_DIALOG(dialog)); if (response == GTK_RESPONSE_CANCEL) { gtk_widget_destroy(dialog); return 0; } idx = gtk_combo_box_get_active(GTK_COMBO_BOX(combobox)); if (idx && idx <= ed->nskeys) { *sign = 1; gpgme_signers_add(ed->ctx, ed->skey_array[idx - 1]); /* -1 because the first option is `None' */ } /* try to loop all the keys in the list * if they are active (the user checked the checkbox in front of the key) * add it to the selected array, finaly make sure that the array * is NULL terminated */ if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(list), &iter)) { capacity = SIZE; *selected = (gpgme_key_t*) malloc(SIZE * sizeof(gpgme_key_t)); idx = 0; sidx = 0; gtk_tree_model_get(GTK_TREE_MODEL(list), &iter, TOGGLE_COLUMN, &active, -1); if (active) (*selected)[sidx++] = ed->key_array[idx]; while (gtk_tree_model_iter_next(GTK_TREE_MODEL(list), &iter)) { ++idx; gtk_tree_model_get(GTK_TREE_MODEL(list), &iter, TOGGLE_COLUMN, &active, -1); if (active) (*selected)[sidx++] = ed->key_array[idx]; if (sidx >= capacity - 1) { capacity += SIZE; *selected = (gpgme_key_t*) realloc(*selected, capacity * sizeof(gpgme_key_t)); } } (*selected)[sidx] = NULL; } else { gtk_widget_destroy(dialog); return 0; } gtk_widget_destroy(dialog); return 1; }
void wxMessageDialog::GTKCreateMsgDialog() { GtkWindow * const parent = m_parent ? GTK_WINDOW(m_parent->m_widget) : NULL; #if wxUSE_LIBHILDON || wxUSE_LIBHILDON2 const char *stockIcon = ""; switch ( GetEffectiveIcon() ) { case wxICON_ERROR: stockIcon = "qgn_note_gene_syserror"; break; case wxICON_WARNING: stockIcon = "qgn_note_gene_syswarning"; break; case wxICON_QUESTION: stockIcon = "qgn_note_confirm"; break; case wxICON_INFORMATION: stockIcon = "qgn_note_info"; break; } // there is no generic note creation function in public API so we have no // choice but to use g_object_new() directly m_widget = (GtkWidget *)g_object_new ( HILDON_TYPE_NOTE, #if wxUSE_LIBHILDON "note_type", HILDON_NOTE_CONFIRMATION_BUTTON_TYPE, #else // wxUSE_LIBHILDON "note_type", HILDON_NOTE_TYPE_CONFIRMATION_BUTTON, #endif // wxUSE_LIBHILDON /wxUSE_LIBHILDON2 "description", (const char *)GetFullMessage().utf8_str(), "icon", stockIcon, NULL ); #else // !wxUSE_LIBHILDON && !wxUSE_LIBHILDON2 GtkMessageType type = GTK_MESSAGE_ERROR; GtkButtonsType buttons = GTK_BUTTONS_NONE; // when using custom labels, we have to add all the buttons ourselves if ( !HasCustomLabels() ) { // "Help" button is not supported by predefined combinations so we // always need to create the buttons manually when it's used. if ( !(m_dialogStyle & wxHELP) ) { if ( m_dialogStyle & wxYES_NO ) { if ( !(m_dialogStyle & wxCANCEL) ) buttons = GTK_BUTTONS_YES_NO; //else: no standard GTK_BUTTONS_YES_NO_CANCEL so leave as NONE } else if ( m_dialogStyle & wxOK ) { buttons = m_dialogStyle & wxCANCEL ? GTK_BUTTONS_OK_CANCEL : GTK_BUTTONS_OK; } } } if ( !wxGTKImpl::ConvertMessageTypeFromWX(GetEffectiveIcon(), &type) ) { // if no style is explicitly specified, detect the suitable icon // ourselves (this can be disabled by using wxICON_NONE) type = m_dialogStyle & wxYES ? GTK_MESSAGE_QUESTION : GTK_MESSAGE_INFO; } wxString message; bool needsExtMessage = false; if (!m_extendedMessage.empty()) { message = m_message; needsExtMessage = true; } else // extended message not needed { message = GetFullMessage(); } m_widget = gtk_message_dialog_new(parent, GTK_DIALOG_MODAL, type, buttons, "%s", (const char*)wxGTK_CONV(message)); if ( needsExtMessage ) { gtk_message_dialog_format_secondary_text ( (GtkMessageDialog *)m_widget, "%s", (const char *)wxGTK_CONV(m_extendedMessage) ); } #endif // wxUSE_LIBHILDON || wxUSE_LIBHILDON2/!wxUSE_LIBHILDON && !wxUSE_LIBHILDON2 g_object_ref(m_widget); if (m_caption != wxMessageBoxCaptionStr) gtk_window_set_title(GTK_WINDOW(m_widget), wxGTK_CONV(m_caption)); GtkDialog * const dlg = GTK_DIALOG(m_widget); if ( m_dialogStyle & wxSTAY_ON_TOP ) { gtk_window_set_keep_above(GTK_WINDOW(m_widget), TRUE); } // we need to add buttons manually if we use custom labels or always for // Yes/No/Cancel dialog as GTK+ doesn't support it natively and when using // Hildon we add all the buttons manually as it doesn't support too many of // the combinations we may have #if wxUSE_LIBHILDON || wxUSE_LIBHILDON2 static const bool addButtons = true; #else // !wxUSE_LIBHILDON const bool addButtons = buttons == GTK_BUTTONS_NONE; #endif // wxUSE_LIBHILDON/!wxUSE_LIBHILDON if ( addButtons ) { if ( m_dialogStyle & wxHELP ) { gtk_dialog_add_button(dlg, wxGTK_CONV(GetHelpLabel()), GTK_RESPONSE_HELP); } if ( m_dialogStyle & wxYES_NO ) // Yes/No or Yes/No/Cancel dialog { // Add the buttons in the correct order which is, according to // http://library.gnome.org/devel/hig-book/stable/windows-alert.html.en // the following one: // // [Help] [Alternative] [Cancel] [Affirmative] gtk_dialog_add_button(dlg, wxGTK_CONV(GetNoLabel()), GTK_RESPONSE_NO); if ( m_dialogStyle & wxCANCEL ) { gtk_dialog_add_button(dlg, wxGTK_CONV(GetCancelLabel()), GTK_RESPONSE_CANCEL); } gtk_dialog_add_button(dlg, wxGTK_CONV(GetYesLabel()), GTK_RESPONSE_YES); } else // Ok or Ok/Cancel dialog { gtk_dialog_add_button(dlg, wxGTK_CONV(GetOKLabel()), GTK_RESPONSE_OK); if ( m_dialogStyle & wxCANCEL ) { gtk_dialog_add_button(dlg, wxGTK_CONV(GetCancelLabel()), GTK_RESPONSE_CANCEL); } } } gint defaultButton; if ( m_dialogStyle & wxCANCEL_DEFAULT ) defaultButton = GTK_RESPONSE_CANCEL; else if ( m_dialogStyle & wxNO_DEFAULT ) defaultButton = GTK_RESPONSE_NO; else if ( m_dialogStyle & wxYES_NO ) defaultButton = GTK_RESPONSE_YES; else // No need to change the default value, whatever it is. defaultButton = GTK_RESPONSE_NONE; if ( defaultButton != GTK_RESPONSE_NONE ) gtk_dialog_set_default_response(dlg, defaultButton); }
static void gdict_pref_dialog_init (GdictPrefDialog *dialog) { gchar *font; GError *error = NULL; gtk_window_set_default_size (GTK_WINDOW (dialog), DEFAULT_MIN_WIDTH, DEFAULT_MIN_HEIGHT); gtk_container_set_border_width (GTK_CONTAINER (dialog), 5); gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), 2); /* add buttons */ gtk_dialog_add_button (GTK_DIALOG (dialog), "gtk-help", GTK_RESPONSE_HELP); gtk_dialog_add_button (GTK_DIALOG (dialog), "gtk-close", GTK_RESPONSE_ACCEPT); dialog->settings = g_settings_new (GDICT_SETTINGS_SCHEMA); /* get the UI from the GtkBuilder file */ dialog->builder = gtk_builder_new (); gtk_builder_add_from_file (dialog->builder, GDICT_PREFERENCES_UI, &error); if (error) { g_critical ("Unable to load the preferences user interface: %s", error->message); g_error_free (error); g_assert_not_reached (); } /* the main widget */ gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), GTK_WIDGET (gtk_builder_get_object (dialog->builder, "preferences_root"))); /* keep all the interesting widgets around */ dialog->notebook = GTK_WIDGET (gtk_builder_get_object (dialog->builder, "preferences_notebook")); dialog->sources_view = GTK_WIDGET (gtk_builder_get_object (dialog->builder, "sources_treeview")); build_sources_view (dialog); dialog->active_source = g_settings_get_string (dialog->settings, GDICT_SETTINGS_SOURCE_KEY); dialog->sources_add = GTK_WIDGET (gtk_builder_get_object (dialog->builder, "add_button")); gtk_widget_set_tooltip_text (dialog->sources_add, _("Add a new dictionary source")); g_signal_connect (dialog->sources_add, "clicked", G_CALLBACK (source_add_clicked_cb), dialog); dialog->sources_remove = GTK_WIDGET (gtk_builder_get_object (dialog->builder, "remove_button")); gtk_widget_set_tooltip_text (dialog->sources_remove, _("Remove the currently selected dictionary source")); g_signal_connect (dialog->sources_remove, "clicked", G_CALLBACK (source_remove_clicked_cb), dialog); dialog->sources_edit = GTK_WIDGET (gtk_builder_get_object (dialog->builder, "edit_button")); gtk_widget_set_tooltip_text (dialog->sources_edit, _("Edit the currently selected dictionary source")); g_signal_connect (dialog->sources_edit, "clicked", G_CALLBACK (source_edit_clicked_cb), dialog); font = g_settings_get_string (dialog->settings, GDICT_SETTINGS_PRINT_FONT_KEY); dialog->font_button = GTK_WIDGET (gtk_builder_get_object (dialog->builder, "print_font_button")); gtk_font_button_set_font_name (GTK_FONT_BUTTON (dialog->font_button), font); gtk_widget_set_tooltip_text (dialog->font_button, _("Set the font used for printing the definitions")); g_signal_connect (dialog->font_button, "font-set", G_CALLBACK (font_button_font_set_cb), dialog); g_free (font); gtk_widget_show_all (dialog->notebook); /* we want to intercept the response signal before any other * callbacks might be attached by the users of the * GdictPrefDialog widget. */ g_signal_connect (dialog, "response", G_CALLBACK (response_cb), NULL); }
bool ConfigDialog::createWindow () { // Create the dialog window mDialog = gtk_dialog_new_with_buttons ( "OGRE Engine Setup", NULL, GTK_DIALOG_MODAL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); mOKButton = gtk_dialog_add_button (GTK_DIALOG (mDialog), GTK_STOCK_OK, GTK_RESPONSE_OK); gtk_window_set_position (GTK_WINDOW (mDialog), GTK_WIN_POS_CENTER); gtk_window_set_resizable (GTK_WINDOW (mDialog), FALSE); gtk_widget_show (GTK_DIALOG (mDialog)->vbox); GtkWidget *vbox = gtk_vbox_new (FALSE, 5); gtk_widget_show (vbox); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (mDialog)->vbox), vbox, TRUE, TRUE, 0); // Unpack the image and create a GtkImage object from it try { static String imgType ("png"); Image img; MemoryDataStream *imgStream; DataStreamPtr imgStreamPtr; imgStream = new MemoryDataStream (GLX_backdrop_data, sizeof (GLX_backdrop_data), false); imgStreamPtr = DataStreamPtr (imgStream); img.load (imgStreamPtr, imgType); PixelBox src = img.getPixelBox (0, 0); size_t width = img.getWidth (); size_t height = img.getHeight (); // Convert and copy image -- must be allocated with malloc uint8 *data = (uint8 *)malloc (width * height * 4); // Keep in mind that PixelBox does not free the data - this is ok // as gtk takes pixel data ownership in gdk_pixbuf_new_from_data PixelBox dst (src, PF_A8B8G8R8, data); PixelUtil::bulkPixelConversion (src, dst); GdkPixbuf *pixbuf = gdk_pixbuf_new_from_data ( (const guchar *)dst.data, GDK_COLORSPACE_RGB, true, 8, width, height, width * 4, backdrop_destructor, NULL); GtkWidget *ogre_logo = gtk_image_new_from_pixbuf (pixbuf); gdk_pixbuf_unref (pixbuf); gtk_widget_show (ogre_logo); gtk_box_pack_start (GTK_BOX (vbox), ogre_logo, FALSE, FALSE, 0); } catch (Exception &e) { // Could not decode image; never mind LogManager::getSingleton().logMessage("WARNING: Failed to decode Ogre logo image"); } GtkWidget *rs_hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), rs_hbox, FALSE, TRUE, 0); GtkWidget *rs_label = gtk_label_new ("Rendering subsystem:"); gtk_widget_show (rs_label); gtk_box_pack_start (GTK_BOX (rs_hbox), rs_label, TRUE, TRUE, 5); gtk_label_set_justify (GTK_LABEL (rs_label), GTK_JUSTIFY_RIGHT); gtk_misc_set_alignment (GTK_MISC (rs_label), 1, 0.5); GtkWidget *rs_cb = gtk_combo_box_new_text (); gtk_widget_show (rs_cb); gtk_box_pack_start (GTK_BOX (rs_hbox), rs_cb, TRUE, TRUE, 5); g_signal_connect (G_OBJECT (rs_cb), "changed", G_CALLBACK (rendererChanged), this); // Add all available renderers to the combo box const RenderSystemList &renderers = Root::getSingleton ().getAvailableRenderers (); uint idx = 0, sel_renderer_idx = 0; for (RenderSystemList::const_iterator r = renderers.begin(); r != renderers.end (); r++, idx++) { gtk_combo_box_append_text (GTK_COMBO_BOX (rs_cb), (*r)->getName ().c_str ()); if (mSelectedRenderSystem == *r) sel_renderer_idx = idx; } // Don't show the renderer choice combobox if there's just one renderer if (idx > 1) gtk_widget_show (rs_hbox); GtkWidget *ro_frame = gtk_frame_new (NULL); gtk_widget_show (ro_frame); gtk_box_pack_start (GTK_BOX (vbox), ro_frame, TRUE, TRUE, 0); GtkWidget *ro_label = gtk_label_new ("Renderer options:"); gtk_widget_show (ro_label); gtk_frame_set_label_widget (GTK_FRAME (ro_frame), ro_label); gtk_label_set_use_markup (GTK_LABEL (ro_label), TRUE); mParamTable = gtk_table_new (0, 0, FALSE); gtk_widget_show (mParamTable); gtk_container_add (GTK_CONTAINER (ro_frame), mParamTable); gtk_combo_box_set_active (GTK_COMBO_BOX (rs_cb), sel_renderer_idx); return true; }
int queryback(struct filetransfer *ft, enum ftquery qtype, const char *msg, ...) { GtkWidget *dialog, *label; va_list l; const char *iter, *percent; char *caption; int i = 0, formatargs = 0; (void)ft; switch(qtype){ case FT_FILE_EXISTS: /* * use radio buttons * query order is: * 0: Overwrite * 1: Resume * 2: Rename */ #ifdef CFG_USE_RADIO if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(opt_Prompt))) break; else if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(opt_Overwrite))) return 0; else if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(opt_Resume))) return 1; else if( gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(opt_AutoRename)) || gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(opt_ManRename )) ) return 2; #else if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(opt_Prompt))) break; else if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(opt_Overwrite))) return 0; else if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(opt_Resume))) return 1; else if( gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(opt_AutoRename)) || gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(opt_ManRename )) ) return 2; #endif /* should be unreachable */ break; case FT_CANT_OPEN: break; } va_start(l, msg); caption = g_strdup_vprintf(msg, l); va_end(l); /* needs reinitialising */ dialog = gtk_dialog_new(); gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(winMain)); gtk_window_set_destroy_with_parent(GTK_WINDOW(dialog), TRUE); gtk_window_set_skip_taskbar_hint(GTK_WINDOW(dialog), FALSE); label = gtk_label_new(caption); /*content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog)); gtk_container_add(GTK_CONTAINER(content_area), label);*/ gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), label); /* button time */ percent = msg-1; while(1) if((percent = strchr(percent+1, '%'))){ if(percent[1] != '%') formatargs++; }else break; /* walk forwards formatargs times, then we're at the button names */ va_start(l, msg); while(formatargs --> 0) va_arg(l, const char *); while((iter = va_arg(l, const char *))) gtk_dialog_add_button(GTK_DIALOG(dialog), iter, i++); va_end(l); gtk_widget_show(label); gtk_window_set_urgency_hint(GTK_WINDOW(dialog), TRUE); gtk_window_set_urgency_hint(GTK_WINDOW(winMain), TRUE); i = gtk_dialog_run(GTK_DIALOG(dialog)); g_free(caption); gtk_widget_destroy(dialog); return i; }
static void source_remove_clicked_cb (GtkWidget *widget, GdictPrefDialog *dialog) { GtkTreeSelection *selection; GtkTreeModel *model; GtkTreeIter iter; gboolean is_selected; gchar *name, *description; selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->sources_view)); if (!selection) return; is_selected = gtk_tree_selection_get_selected (selection, &model, &iter); if (!is_selected) return; gtk_tree_model_get (model, &iter, SOURCES_NAME_COLUMN, &name, SOURCES_DESCRIPTION_COLUMN, &description, -1); if (!name) return; else { GtkWidget *confirm_dialog; gint response; confirm_dialog = gtk_message_dialog_new (GTK_WINDOW (dialog), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE, _("Remove \"%s\"?"), description); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (confirm_dialog), _("This will permanently remove the " "dictionary source from the list.")); gtk_dialog_add_button (GTK_DIALOG (confirm_dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); gtk_dialog_add_button (GTK_DIALOG (confirm_dialog), GTK_STOCK_REMOVE, GTK_RESPONSE_OK); gtk_window_set_title (GTK_WINDOW (confirm_dialog), ""); response = gtk_dialog_run (GTK_DIALOG (confirm_dialog)); if (response == GTK_RESPONSE_CANCEL) { gtk_widget_destroy (confirm_dialog); goto out; } gtk_widget_destroy (confirm_dialog); } if (gdict_source_loader_remove_source (dialog->loader, name)) gtk_list_store_remove (GTK_LIST_STORE (model), &iter); else { GtkWidget *error_dialog; gchar *message; message = g_strdup_printf (_("Unable to remove source '%s'"), description); error_dialog = gtk_message_dialog_new (GTK_WINDOW (dialog), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "%s", message); gtk_window_set_title (GTK_WINDOW (error_dialog), ""); gtk_dialog_run (GTK_DIALOG (error_dialog)); gtk_widget_destroy (error_dialog); } out: g_free (name); g_free (description); update_sources_view (dialog); }
static gint glspi_choose(lua_State* L) { const gchar *arg1=NULL; gint i, n; GtkResponseType rv; GtkWidget*dialog, *ok_btn, *cancel_btn, *tree, *scroll; GtkListStore *store; GtkTreeIter iter; GtkTreeSelection *select; if ( (lua_gettop(L)!=2) || (!lua_istable(L,2)) ) { return FAIL_TABLE_ARG(2); } if (!lua_isnil(L, 1)) { if (!lua_isstring(L, 1)) { return FAIL_STRING_ARG(1); } arg1=lua_tostring(L, 1); } n=lua_objlen(L,2); for (i=1;i<=n; i++) { lua_rawgeti(L,2,i); if (!lua_isstring(L, -1)) { return glspi_fail_elem_type(L, __FUNCTION__, 2, i, "string"); } lua_pop(L, 1); } store=gtk_list_store_new(1, G_TYPE_STRING); for (i=1;i<=n; i++) { lua_rawgeti(L,2,i); gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, 0, lua_tostring(L, -1), -1); lua_pop(L, 1); } dialog = new_dlg(GTK_MESSAGE_OTHER, GTK_BUTTONS_NONE, arg1, NULL); ok_btn=gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_OK, GTK_RESPONSE_OK); cancel_btn=gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); gtk_widget_grab_default(ok_btn); set_dialog_title(L,dialog); tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), FALSE); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(tree), -1, NULL, gtk_cell_renderer_text_new(), "text", 0, NULL); select = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree)); gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE); scroll=gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox),scroll); gtk_container_add(GTK_CONTAINER(scroll),tree); gtk_widget_set_size_request(tree, 320, 240); gtk_widget_show_all(dialog); gtk_window_set_resizable(GTK_WINDOW(dialog), TRUE); gtk_signal_connect(GTK_OBJECT(tree), "button-press-event", GTK_SIGNAL_FUNC(on_tree_clicked), dialog); gtk_signal_connect(GTK_OBJECT(tree), "key-release-event", GTK_SIGNAL_FUNC(on_tree_key_release), dialog); rv=glspi_dialog_run(GTK_DIALOG(dialog)); if (GTK_RESPONSE_OK == rv ) { gchar *txt=NULL; GtkTreeModel *model; if (gtk_tree_selection_get_selected(select, &model, &iter)) { gtk_tree_model_get(model, &iter, 0, &txt, -1); } if (txt) { lua_pushstring(L, txt); g_free(txt); } else { lua_pushnil(L); } } else { lua_pushnil(L); } gtk_widget_destroy(dialog); return 1; }
static void message_dialog (GtkMessageType message_type, const gchar *message, Git *plugin) { const gchar *dialog_title; GtkWidget *image; GtkWidget *dialog; GtkWidget *close_button; GtkWidget *content_area; GtkWidget *hbox; GtkWidget *scrolled_window; GtkWidget *text_view; GtkTextBuffer *text_buffer; dialog_title = NULL; image = gtk_image_new (); switch (message_type) { case GTK_MESSAGE_ERROR: gtk_image_set_from_icon_name (GTK_IMAGE (image), GTK_STOCK_DIALOG_ERROR, GTK_ICON_SIZE_DIALOG); dialog_title = _("Git Error"); break; case GTK_MESSAGE_WARNING: gtk_image_set_from_icon_name (GTK_IMAGE (image), GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_DIALOG); dialog_title = _("Git Warning"); break; default: break; } dialog = gtk_dialog_new_with_buttons (dialog_title, GTK_WINDOW (ANJUTA_PLUGIN (plugin)->shell), GTK_DIALOG_DESTROY_WITH_PARENT, NULL); close_button = gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); hbox = gtk_hbox_new (FALSE, 2); scrolled_window = gtk_scrolled_window_new (NULL, NULL); text_view = gtk_text_view_new (); text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view)); gtk_window_set_default_size (GTK_WINDOW (dialog), 550, 200); gtk_container_add (GTK_CONTAINER (scrolled_window), text_view); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_text_view_set_editable (GTK_TEXT_VIEW (text_view), FALSE); gtk_text_buffer_set_text (text_buffer, message, strlen (message)); gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), scrolled_window, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (content_area), hbox, TRUE, TRUE, 0); gtk_widget_grab_default (close_button); gtk_widget_grab_focus (close_button); g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (gtk_widget_destroy), NULL); gtk_widget_show_all (dialog); }
void gs_page_remove_app (GsPage *page, GsApp *app, GCancellable *cancellable) { GsPagePrivate *priv = gs_page_get_instance_private (page); GsPageHelper *helper; GtkWidget *dialog; g_autofree gchar *message = NULL; g_autofree gchar *title = NULL; /* pending install */ helper = g_slice_new0 (GsPageHelper); helper->action = GS_PLUGIN_ACTION_REMOVE; helper->app = g_object_ref (app); helper->page = g_object_ref (page); helper->cancellable = g_object_ref (cancellable); if (gs_app_get_state (app) == AS_APP_STATE_QUEUED_FOR_INSTALL) { g_autoptr(GsPluginJob) plugin_job = NULL; plugin_job = gs_plugin_job_newv (GS_PLUGIN_ACTION_REMOVE, "interactive", TRUE, "app", app, NULL); g_debug ("remove %s", gs_app_get_id (app)); gs_plugin_loader_job_process_async (priv->plugin_loader, plugin_job, helper->cancellable, gs_page_app_removed_cb, helper); return; } /* use different name and summary */ switch (gs_app_get_kind (app)) { case AS_APP_KIND_SOURCE: /* TRANSLATORS: this is a prompt message, and '%s' is an * repository name, e.g. 'GNOME Nightly' */ title = g_strdup_printf (_("Are you sure you want to remove " "the %s repository?"), gs_app_get_name (app)); /* TRANSLATORS: longer dialog text */ message = g_strdup_printf (_("All applications from %s will be " "removed, and you will have to " "re-install the repository to use them again."), gs_app_get_name (app)); break; default: /* TRANSLATORS: this is a prompt message, and '%s' is an * application summary, e.g. 'GNOME Clocks' */ title = g_strdup_printf (_("Are you sure you want to remove %s?"), gs_app_get_name (app)); /* TRANSLATORS: longer dialog text */ message = g_strdup_printf (_("%s will be removed, and you will " "have to install it to use it again."), gs_app_get_name (app)); break; } /* ask for confirmation */ dialog = gtk_message_dialog_new (gs_shell_get_window (priv->shell), GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_CANCEL, "%s", title); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "%s", message); /* TRANSLATORS: this is button text to remove the application */ gtk_dialog_add_button (GTK_DIALOG (dialog), _("Remove"), GTK_RESPONSE_OK); /* handle this async */ g_signal_connect (dialog, "response", G_CALLBACK (gs_page_remove_app_response_cb), helper); gs_shell_modal_dialog_present (priv->shell, GTK_DIALOG (dialog)); }
GtkWidget* gtr_torrent_options_dialog_new( GtkWindow * parent, TrCore * core, tr_ctor * ctor ) { guint row; guint col; const char * str; GtkWidget * w; GtkWidget * d; GtkWidget * t; GtkWidget * l; GtkWidget * grab; GtkWidget * source_chooser; struct OpenData * data; bool flag; GSList * list; GSList * walk; /* make the dialog */ d = gtk_dialog_new_with_buttons( _( "Torrent Options" ), parent, GTK_DIALOG_DESTROY_WITH_PARENT, NULL ); gtk_dialog_add_button( GTK_DIALOG( d ), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL ); grab = gtk_dialog_add_button( GTK_DIALOG( d ), GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT ); gtk_dialog_set_default_response( GTK_DIALOG( d ), GTK_RESPONSE_ACCEPT ); gtk_dialog_set_alternative_button_order( GTK_DIALOG( d ), GTK_RESPONSE_ACCEPT, GTK_RESPONSE_CANCEL, -1 ); if( tr_ctorGetDownloadDir( ctor, TR_FORCE, &str ) ) g_assert_not_reached( ); g_assert( str ); data = g_new0( struct OpenData, 1 ); data->core = core; data->ctor = ctor; data->filename = g_strdup( tr_ctorGetSourceFile( ctor ) ); data->downloadDir = g_strdup( str ); data->file_list = gtr_file_list_new( core, 0 ); str = _( "Mo_ve .torrent file to the trash" ); data->trash_check = gtk_check_button_new_with_mnemonic( str ); str = _( "_Start when added" ); data->run_check = gtk_check_button_new_with_mnemonic( str ); w = data->priority_combo = gtr_priority_combo_new( ); gtr_priority_combo_set_value( GTK_COMBO_BOX( w ), TR_PRI_NORMAL ); g_signal_connect( G_OBJECT( d ), "response", G_CALLBACK( addResponseCB ), data ); t = gtk_table_new( 6, 2, FALSE ); gtk_container_set_border_width( GTK_CONTAINER( t ), GUI_PAD_BIG ); gtk_table_set_row_spacings( GTK_TABLE( t ), GUI_PAD ); gtk_table_set_col_spacings( GTK_TABLE( t ), GUI_PAD_BIG ); row = col = 0; l = gtk_label_new_with_mnemonic( _( "_Torrent file:" ) ); gtk_misc_set_alignment( GTK_MISC( l ), 0.0f, 0.5f ); gtk_table_attach( GTK_TABLE( t ), l, col, col + 1, row, row + 1, GTK_FILL, 0, 0, 0 ); ++col; w = gtk_file_chooser_button_new( _( "Select Source File" ), GTK_FILE_CHOOSER_ACTION_OPEN ); source_chooser = w; gtk_table_attach( GTK_TABLE( t ), w, col, col + 1, row, row + 1, ~0, 0, 0, 0 ); gtk_label_set_mnemonic_widget( GTK_LABEL( l ), w ); addTorrentFilters( GTK_FILE_CHOOSER( w ) ); g_signal_connect( w, "selection-changed", G_CALLBACK( sourceChanged ), data ); ++row; col = 0; l = gtk_label_new_with_mnemonic( _( "_Destination folder:" ) ); gtk_misc_set_alignment( GTK_MISC( l ), 0.0f, 0.5f ); gtk_table_attach( GTK_TABLE( t ), l, col, col + 1, row, row + 1, GTK_FILL, 0, 0, 0 ); ++col; w = gtk_file_chooser_button_new( _( "Select Destination Folder" ), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ); if( !gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( w ), data->downloadDir ) ) g_warning( "couldn't select '%s'", data->downloadDir ); list = get_recent_destinations( ); for( walk = list; walk; walk = walk->next ) gtk_file_chooser_add_shortcut_folder( GTK_FILE_CHOOSER( w ), walk->data, NULL ); g_slist_free( list ); gtk_table_attach( GTK_TABLE( t ), w, col, col + 1, row, row + 1, ~0, 0, 0, 0 ); gtk_label_set_mnemonic_widget( GTK_LABEL( l ), w ); g_signal_connect( w, "selection-changed", G_CALLBACK( downloadDirChanged ), data ); ++row; col = 0; w = data->file_list; gtk_widget_set_size_request ( w, 466u, 300u ); gtk_table_attach_defaults( GTK_TABLE( t ), w, col, col + 2, row, row + 1 ); ++row; col = 0; w = gtk_label_new_with_mnemonic( _( "Torrent _priority:" ) ); gtk_misc_set_alignment( GTK_MISC( w ), 0.0f, 0.5f ); gtk_table_attach( GTK_TABLE( t ), w, col, col + 1, row, row + 1, ~0, 0, 0, 0 ); ++col; gtk_table_attach( GTK_TABLE( t ), data->priority_combo, col, col + 1, row, row + 1, ~0, 0, 0, 0 ); gtk_label_set_mnemonic_widget( GTK_LABEL( w ), data->priority_combo ); ++row; col = 0; w = data->run_check; if( tr_ctorGetPaused( ctor, TR_FORCE, &flag ) ) g_assert_not_reached( ); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), !flag ); gtk_table_attach( GTK_TABLE( t ), w, col, col + 2, row, row + 1, GTK_FILL, 0, 0, 0 ); ++row; col = 0; w = data->trash_check; if( tr_ctorGetDeleteSource( ctor, &flag ) ) g_assert_not_reached( ); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), flag ); gtk_table_attach( GTK_TABLE( t ), w, col, col + 2, row, row + 1, GTK_FILL, 0, 0, 0 ); /* trigger sourceChanged, either directly or indirectly, * so that it creates the tor/gtor objects */ w = source_chooser; if( data->filename ) gtk_file_chooser_set_filename( GTK_FILE_CHOOSER( w ), data->filename ); else sourceChanged( GTK_FILE_CHOOSER_BUTTON( w ), data ); gtr_dialog_set_content( GTK_DIALOG( d ), t ); gtk_widget_grab_focus( grab ); return d; }
void GtkNSSSecurityWarningDialogs::DoDialog (nsIInterfaceRequestor *aContext, const char *aPrefName, GtkMessageType aType, GtkButtonsType aButtons, int aDefaultResponse, const char *aPrimary, const char *aSecondary, const char *aButtonText, PRBool *_retval) { if (_retval) *_retval = PR_FALSE; nsresult rv; PRBool show = PR_TRUE; nsCOMPtr<nsIPrefBranch> prefBranch (do_GetService (NS_PREFSERVICE_CONTRACTID)); if (prefBranch && aPrefName) { rv = prefBranch->GetBoolPref (aPrefName, &show); if (NS_FAILED(rv)) show = PR_TRUE; } char *showOncePref = NULL; PRBool showOnce = PR_FALSE; if (!show && prefBranch && aPrefName) { showOncePref = g_strconcat (aPrefName, ".show_once", NULL); rv = prefBranch->GetBoolPref (showOncePref, &showOnce); if (NS_FAILED (rv)) showOnce = PR_FALSE; } if (!show && !showOnce) { g_free (showOncePref); if (_retval) *_retval = PR_TRUE; return; } AutoJSContextStack stack; rv = stack.Init (); if (NS_FAILED (rv)) return; /* Didn't you know it, mozilla SUCKS! * the "aContext" interface requestor is made from a nsIDOMWindow, * but can only give out a nsIPrompt, from where there's no way to get * the nsIDOMWindow back! * * However GaleonUtils::FindGtkParent falls back to the current active * window so this vageuly works for us at the moment * * https://bugzilla.mozilla.org/show_bug.cgi?id=277587 */ nsCOMPtr<nsIDOMWindow> domWin (do_GetInterface (aContext)); GtkWidget *parent = GaleonUtils::FindGtkParent (domWin); GtkDialogFlags flags = parent ? (GtkDialogFlags)0 : GTK_DIALOG_MODAL; #if GTK_CHECK_VERSION(2,6,0) GtkWidget *dialog = gtk_message_dialog_new (GTK_WINDOW (parent), flags, aType, aButtons, "%s", aPrimary); if (aSecondary) { gtk_message_dialog_format_secondary_markup (GTK_MESSAGE_DIALOG (dialog), "%s", aSecondary); } #else GtkWidget *dialog = hig_alert_new (GTK_WINDOW (parent), flags, aType == GTK_MESSAGE_INFO ? HIG_ALERT_INFORMATION : HIG_ALERT_CONFIRMATION, aPrimary, aSecondary, NULL); if (aButtons == GTK_BUTTONS_OK) { gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_OK, GTK_RESPONSE_OK); } else if (aButtons == GTK_BUTTONS_CANCEL) { gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); } else { g_assert_not_reached(); } #endif if (parent && GTK_WINDOW (parent)->group) { gtk_window_group_add_window (GTK_WINDOW (parent)->group, GTK_WINDOW (dialog)); } if (aButtonText) { gtk_dialog_add_button (GTK_DIALOG (dialog), aButtonText, GTK_RESPONSE_ACCEPT); } gtk_dialog_set_default_response (GTK_DIALOG (dialog), aDefaultResponse); int response = gtk_dialog_run (GTK_DIALOG (dialog)); if (_retval) *_retval = response == GTK_RESPONSE_ACCEPT; if (prefBranch && showOncePref && showOnce) { prefBranch->SetBoolPref (showOncePref, PR_FALSE); } gtk_widget_destroy (dialog); g_free (showOncePref); }
/** * main: **/ int main (int argc, char **argv) { gboolean ret; const gchar *copyright; const gchar *description; GFile *destination = NULL; GFile *file = NULL; gchar **files = NULL; guint retval = 1; McmProfile *profile = NULL; McmColorspace colorspace; GError *error = NULL; GOptionContext *context; GString *string = NULL; GtkWidget *dialog; GtkResponseType response; GtkWidget *cie_widget = NULL; McmXyz *white = NULL; McmXyz *red = NULL; McmXyz *green = NULL; McmXyz *blue = NULL; const GOptionEntry options[] = { { G_OPTION_REMAINING, '\0', 0, G_OPTION_ARG_FILENAME_ARRAY, &files, /* TRANSLATORS: command line option: a list of catalogs to install */ _("ICC profile to install"), NULL }, { NULL} }; setlocale (LC_ALL, ""); bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); gtk_init (&argc, &argv); context = g_option_context_new ("mate-color-manager import program"); g_option_context_add_main_entries (context, options, NULL); g_option_context_add_group (context, egg_debug_get_option_group ()); g_option_context_add_group (context, gtk_get_option_group (TRUE)); g_option_context_parse (context, &argc, &argv, NULL); g_option_context_free (context); /* nothing sent */ if (files == NULL) { /* TRANSLATORS: nothing was specified on the command line */ dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, _("No filename specified")); gtk_window_set_icon_name (GTK_WINDOW (dialog), MCM_STOCK_ICON); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); goto out; } /* load profile */ profile = mcm_profile_default_new (); file = g_file_new_for_path (files[0]); ret = mcm_profile_parse (profile, file, &error); if (!ret) { /* TRANSLATORS: could not read file */ dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, _("Failed to open ICC profile")); gtk_window_set_icon_name (GTK_WINDOW (dialog), MCM_STOCK_ICON); /* TRANSLATORS: parsing error */ gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), _("Failed to parse file: %s"), error->message); gtk_dialog_run (GTK_DIALOG (dialog)); g_error_free (error); gtk_widget_destroy (dialog); goto out; } /* get data */ description = mcm_profile_get_description (profile); copyright = mcm_profile_get_copyright (profile); colorspace = mcm_profile_get_colorspace (profile); g_object_get (profile, "white", &white, "red", &red, "green", &green, "blue", &blue, NULL); /* use CIE widget */ cie_widget = mcm_cie_widget_new (); gtk_widget_set_size_request (cie_widget, 200, 200); g_object_set (cie_widget, "use-grid", FALSE, "use-whitepoint", FALSE, "white", white, "red", red, "green", green, "blue", blue, NULL); /* check file does't already exist */ destination = mcm_utils_get_profile_destination (file); ret = g_file_query_exists (destination, NULL); if (ret) { /* TRANSLATORS: color profile already been installed */ dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE, _("ICC profile already installed")); gtk_window_set_icon_name (GTK_WINDOW (dialog), MCM_STOCK_ICON); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "%s\n%s", description, copyright); /* add cie widget */ mcm_import_add_cie_widget (GTK_DIALOG(dialog), cie_widget); gtk_window_set_resizable (GTK_WINDOW (dialog), TRUE); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); goto out; } /* create message */ string = g_string_new (""); if (description != NULL) { /* TRANSLATORS: message text */ g_string_append_printf (string, _("Import ICC color profile %s?"), description); } else { /* TRANSLATORS: message text */ g_string_append (string, _("Import ICC color profile?")); } /* add copyright */ if (copyright != NULL) g_string_append_printf (string, "\n%s", copyright); /* ask confirmation */ dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_CLOSE, "%s", _("Import ICC profile")); gtk_window_set_icon_name (GTK_WINDOW (dialog), MCM_STOCK_ICON); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "%s", string->str); /* TRANSLATORS: button text */ gtk_dialog_add_button (GTK_DIALOG (dialog), _("Install"), GTK_RESPONSE_OK); /* add cie widget */ mcm_import_add_cie_widget (GTK_DIALOG(dialog), cie_widget); /* only show the cie widget if we have RGB data */ if (colorspace != MCM_COLORSPACE_RGB) gtk_widget_hide (cie_widget); gtk_window_set_resizable (GTK_WINDOW (dialog), TRUE); response = gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); /* not the correct response */ if (response != GTK_RESPONSE_OK) goto out; /* copy icc file to users profile path */ ret = mcm_utils_mkdir_and_copy (file, destination, &error); if (!ret) { /* TRANSLATORS: could not read file */ dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, _("Failed to copy file")); gtk_window_set_icon_name (GTK_WINDOW (dialog), MCM_STOCK_ICON); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "%s", error->message); gtk_dialog_run (GTK_DIALOG (dialog)); g_error_free (error); gtk_widget_destroy (dialog); goto out; } /* open up the preferences */ ret = g_spawn_command_line_async (BINDIR "/mcm-prefs", &error); if (!ret) { egg_warning ("failed to spawn preferences: %s", error->message); g_error_free (error); goto out; } out: if (file != NULL) g_object_unref (file); if (white != NULL) g_object_unref (white); if (red != NULL) g_object_unref (red); if (green != NULL) g_object_unref (green); if (blue != NULL) g_object_unref (blue); if (string != NULL) g_string_free (string, TRUE); if (profile != NULL) g_object_unref (profile); if (destination != NULL) g_object_unref (destination); g_strfreev (files); return retval; }
static void tip_model_dialog(TipModelArgs *args) { enum { RESPONSE_RESET = 1, RESPONSE_PREVIEW = 2 }; GtkWidget *dialog, *table, *hbox, *spin; TipModelControls controls; GwyPixmapLayer *layer; GwyDataField *dfield; GwySIUnit *unit; GQuark quark; gint response, row; dialog = gtk_dialog_new_with_buttons(_("Model Tip"), NULL, 0, NULL); gtk_dialog_add_action_widget(GTK_DIALOG(dialog), gwy_stock_like_button_new(_("_Update"), GTK_STOCK_EXECUTE), RESPONSE_PREVIEW); gtk_dialog_add_button(GTK_DIALOG(dialog), _("_Reset"), RESPONSE_RESET); gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_OK, GTK_RESPONSE_OK); gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK); hbox = gtk_hbox_new(FALSE, 3); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, FALSE, FALSE, 4); controls.args = args; controls.vxres = 200; controls.vyres = 200; /* set up initial tip field */ quark = gwy_app_get_data_key_for_id(args->object.id); dfield = GWY_DATA_FIELD(gwy_container_get_object(args->object.data, quark)); controls.tip = gwy_data_field_new_alike(dfield, TRUE); gwy_data_field_resample(controls.tip, controls.vxres, controls.vyres, GWY_INTERPOLATION_NONE); gwy_data_field_clear(controls.tip); /*set up data of rescaled image of the tip*/ controls.vtip = gwy_container_new(); gwy_app_sync_data_items(args->object.data, controls.vtip, args->object.id, 0, FALSE, GWY_DATA_ITEM_PALETTE, 0); dfield = gwy_data_field_new_alike(controls.tip, TRUE); gwy_container_set_object_by_name(controls.vtip, "/0/data", dfield); g_object_unref(dfield); /* set up resampled view */ controls.view = gwy_data_view_new(controls.vtip); layer = gwy_layer_basic_new(); gwy_pixmap_layer_set_data_key(layer, "/0/data"); gwy_layer_basic_set_gradient_key(GWY_LAYER_BASIC(layer), "/0/base/palette"); gwy_data_view_set_base_layer(GWY_DATA_VIEW(controls.view), layer); /* set up tip model controls */ gtk_box_pack_start(GTK_BOX(hbox), controls.view, FALSE, FALSE, 4); table = gtk_table_new(6, 4, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 2); gtk_table_set_col_spacings(GTK_TABLE(table), 6); gtk_container_set_border_width(GTK_CONTAINER(table), 4); gtk_box_pack_start(GTK_BOX(hbox), table, FALSE, FALSE, 4); row = 0; controls.type = create_preset_menu(G_CALLBACK(tip_type_cb), &controls, args->type); gwy_table_attach_hscale(table, row, _("Tip _type:"), NULL, GTK_OBJECT(controls.type), GWY_HSCALE_WIDGET); row++; controls.nsides = gtk_adjustment_new(args->nsides, 3, 24, 1, 5, 0); gwy_table_attach_hscale(table, row, _("_Number of sides:"), NULL, controls.nsides, 0); row++; controls.angle = gtk_adjustment_new(args->angle, 0.1, 89.9, 0.1, 1, 0); spin = gwy_table_attach_hscale(table, row, _("Tip _slope:"), _("deg"), controls.angle, 0); gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), 2); row++; controls.theta = gtk_adjustment_new(args->theta, 0, 360, 0.1, 1, 0); spin = gwy_table_attach_hscale(table, row, _("Tip _rotation:"), _("deg"), controls.theta, 0); gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), 2); row++; controls.radius = gtk_adjustment_new(1.0, 0.01, 1000.0, 0.01, 1.0, 0.0); controls.radius_spin = gtk_spin_button_new(GTK_ADJUSTMENT(controls.radius), 0.1, 2); gtk_table_attach(GTK_TABLE(table), controls.radius_spin, 2, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); controls.radius_label = gtk_label_new_with_mnemonic(_("Tip _apex radius:")); gtk_misc_set_alignment(GTK_MISC(controls.radius_label), 0.0, 0.5); gtk_label_set_mnemonic_widget(GTK_LABEL(controls.radius_label), controls.radius_spin); gtk_table_attach(GTK_TABLE(table), controls.radius_label, 0, 1, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); unit = gwy_data_field_get_si_unit_xy(dfield); controls.radius_unit = gwy_combo_box_metric_unit_new(G_CALLBACK(radius_changed_cb), &controls, -12, -3, unit, -9); gtk_table_attach(GTK_TABLE(table), controls.radius_unit, 3, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); g_signal_connect(controls.radius, "value-changed", G_CALLBACK(radius_changed_cb), &controls); row++; controls.labsize = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(controls.labsize), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), controls.labsize, 0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); row++; controls.tipdone = FALSE; tip_model_dialog_update_controls(&controls, args); preview(&controls, args); gtk_widget_show_all(dialog); do { response = gtk_dialog_run(GTK_DIALOG(dialog)); switch (response) { case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_DELETE_EVENT: tip_model_dialog_update_values(&controls, args); gtk_widget_destroy(dialog); tip_model_dialog_abandon(&controls); case GTK_RESPONSE_NONE: return; break; case GTK_RESPONSE_OK: tip_model_do(args, &controls); break; case RESPONSE_RESET: args->nsides = tip_model_defaults.nsides; args->angle = tip_model_defaults.angle; args->radius = tip_model_defaults.radius; args->theta = tip_model_defaults.theta; args->type = tip_model_defaults.type; tip_model_dialog_update_controls(&controls, args); break; case RESPONSE_PREVIEW: tip_model_dialog_update_values(&controls, args); preview(&controls, args); break; default: g_assert_not_reached(); break; } } while (response != GTK_RESPONSE_OK); tip_model_dialog_update_values(&controls, args); gtk_widget_destroy(dialog); tip_model_dialog_abandon(&controls); }
/** * wbcg_edit_start: * @wbcg: The workbook to be edited. * @blankp: If true, erase current cell contents first. If false, leave the * contents alone. * @cursorp: If true, create an editing cursor in the current sheet. (If * false, the text will be editing in the edit box above the sheet, * but this is not handled by this function.) * * Initiate editing of a cell in the sheet. Note that we have two modes of * editing: * 1) in-cell editing when you just start typing, and * 2) above sheet editing when you hit F2. * * Returns TRUE if we did indeed start editing. Returns FALSE if the * cell-to-be-edited was locked. */ gboolean wbcg_edit_start (WBCGtk *wbcg, gboolean blankp, gboolean cursorp) { /* We could save this, but the situation is rare, if confusing. */ static gboolean warn_on_text_format = TRUE; SheetView *sv; SheetControlGUI *scg; GnmCell *cell; char *text = NULL; int col, row; WorkbookView *wbv; int cursor_pos = -1; g_return_val_if_fail (GNM_IS_WBC_GTK (wbcg), FALSE); if (wbcg_is_editing (wbcg)) return TRUE; /* Avoid recursion, and do not begin editing if a guru is up */ if (wbcg->inside_editing || wbc_gtk_get_guru (wbcg) != NULL) return TRUE; wbcg->inside_editing = TRUE; wbv = wb_control_view (GNM_WBC (wbcg)); sv = wb_control_cur_sheet_view (GNM_WBC (wbcg)); scg = wbcg_cur_scg (wbcg); col = sv->edit_pos.col; row = sv->edit_pos.row; /* don't edit a locked cell */ /* TODO : extend this to disable edits that cannot succeed * like editing a single cell of an array. I think we have enough * information if we look at the selection. */ if (wb_view_is_protected (wbv, TRUE) && gnm_style_get_contents_locked (sheet_style_get (sv->sheet, col, row))) { char *pos = g_strdup_printf ( _("%s!%s is locked"), sv->sheet->name_quoted, cell_coord_name (col, row)); go_cmd_context_error_invalid (GO_CMD_CONTEXT (wbcg), pos, wb_view_is_protected (wbv, FALSE) ? _("Unprotect the workbook to enable editing.") : _("Unprotect the sheet to enable editing.")); wbcg->inside_editing = FALSE; g_free (pos); return FALSE; } cell = sheet_cell_get (sv->sheet, col, row); if (cell && warn_on_text_format && go_format_is_text (gnm_cell_get_format (cell)) && (gnm_cell_has_expr (cell) || !VALUE_IS_STRING (cell->value))) { gint res; /* Using GtkResponseType would yield a warning on the switch */ GtkWidget *check; GtkWidget *align; GtkWidget *d = gnm_message_dialog_create (wbcg_toplevel (wbcg), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_WARNING, _("You are about to edit a cell with \"text\" format."), _("The cell does not currently contain text, though, so if " "you go on editing then the contents will be turned into " "text.")); gtk_dialog_add_button (GTK_DIALOG (d), GTK_STOCK_EDIT, GTK_RESPONSE_OK); go_gtk_dialog_add_button (GTK_DIALOG (d), _("Remove format"), GTK_STOCK_REMOVE, GNM_RESPONSE_REMOVE); gtk_dialog_add_button (GTK_DIALOG (d), GNM_STOCK_CANCEL, GTK_RESPONSE_CANCEL); gtk_dialog_set_default_response (GTK_DIALOG (d), GTK_RESPONSE_CANCEL); check = gtk_check_button_new_with_label (_("Show this dialog next time.")); g_signal_connect (check, "toggled", G_CALLBACK (cb_warn_toggled), &warn_on_text_format); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE); align = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_container_add (GTK_CONTAINER (align), check); gtk_widget_show_all (align); gtk_box_pack_end (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (d))), align, TRUE, TRUE, 0); res = go_gtk_dialog_run (GTK_DIALOG (d), wbcg_toplevel (wbcg)); switch (res) { case GNM_RESPONSE_REMOVE: { GnmStyle *style = gnm_style_new (); gnm_style_set_format (style, go_format_general ()); if (!cmd_selection_format (GNM_WBC (wbcg), style, NULL, NULL)) break; /* Fall through. */ } default: case GTK_RESPONSE_CANCEL: wbcg->inside_editing = FALSE; return FALSE; case GTK_RESPONSE_OK: break; } } gnm_app_clipboard_unant (); if (blankp) gtk_entry_set_text (wbcg_get_entry (wbcg), ""); else if (cell != NULL) { gboolean quoted = FALSE; text = gnm_cell_get_text_for_editing (cell, sv->sheet, "ed, &cursor_pos); if (text) gtk_entry_set_text (wbcg_get_entry (wbcg), text); if (cell->value != NULL) { GOFormat const *fmt = VALUE_FMT (cell->value); if (fmt != NULL && go_format_is_markup (fmt)) { PangoAttrList *markup = pango_attr_list_copy ((PangoAttrList *)go_format_get_markup (fmt)); if (quoted) go_pango_attr_list_open_hole (markup, 0, 1); wbcg_edit_init_markup (wbcg, markup); } } } gnm_expr_entry_set_scg (wbcg->edit_line.entry, scg); gnm_expr_entry_set_flags (wbcg->edit_line.entry, GNM_EE_SHEET_OPTIONAL | GNM_EE_FORMULA_ONLY, GNM_EE_SINGLE_RANGE | GNM_EE_SHEET_OPTIONAL | GNM_EE_FORMULA_ONLY | GNM_EE_FORCE_REL_REF | GNM_EE_FORCE_ABS_REF); scg_edit_start (scg); /* Redraw the cell contents in case there was a span */ sheet_redraw_region (sv->sheet, col, row, col, row); if (cursorp && /* autocompletion code will not work in the edit line */ wbv->do_auto_completion && (text == NULL || g_unichar_isalpha (g_utf8_get_char (text)))) { wbcg->auto_complete = gnm_complete_sheet_new ( sv->sheet, col, row, workbook_edit_complete_notify, wbcg); wbcg->auto_completing = TRUE; wbcg->auto_max_size = 0; } else wbcg->auto_complete = NULL; /* Give the focus to the edit line */ if (!cursorp) gtk_window_set_focus (wbcg_toplevel (wbcg), (GtkWidget *) wbcg_get_entry (wbcg)); wbcg->editing = TRUE; wbcg->editing_sheet = sv->sheet; wbcg->editing_cell = cell; /* If this assert fails, it means editing was not shut down * properly before */ g_return_val_if_fail (wbcg->edit_line.signal_changed == 0, TRUE); wbcg->edit_line.signal_changed = g_signal_connect ( G_OBJECT (wbcg_get_entry (wbcg)), "changed", G_CALLBACK (cb_entry_changed), wbcg); wbcg->edit_line.signal_insert = g_signal_connect ( G_OBJECT (wbcg_get_entry (wbcg)), "insert-text", G_CALLBACK (cb_entry_insert_text), wbcg); wbcg->edit_line.signal_delete = g_signal_connect ( G_OBJECT (wbcg_get_entry (wbcg)), "delete-text", G_CALLBACK (cb_entry_delete_text), wbcg); wbcg->edit_line.signal_cursor_pos = g_signal_connect_swapped ( G_OBJECT (wbcg_get_entry (wbcg)), "notify::cursor-position", G_CALLBACK (cb_entry_cursor_pos), wbcg); wbcg->edit_line.signal_selection_bound = g_signal_connect_swapped ( G_OBJECT (wbcg_get_entry (wbcg)), "notify::selection-bound", G_CALLBACK (cb_entry_cursor_pos), wbcg); g_free (text); wb_control_update_action_sensitivity (GNM_WBC (wbcg)); wbcg->inside_editing = FALSE; gtk_editable_set_position (GTK_EDITABLE (wbcg_get_entry (wbcg)), cursor_pos); return TRUE; }
static gboolean confirm_delete_immediately (GtkWidget *parent_view, gint num_files, gboolean all) { GdkScreen *screen; GtkWidget *dialog, *hbox, *vbox, *image, *label; gchar *str, *prompt, *detail; int response; screen = gtk_widget_get_screen (parent_view); dialog = gtk_dialog_new (); gtk_window_set_screen (GTK_WINDOW (dialog), screen); atk_object_set_role (gtk_widget_get_accessible (dialog), ATK_ROLE_ALERT); gtk_window_set_title (GTK_WINDOW (dialog), _("Delete Immediately?")); gtk_container_set_border_width (GTK_CONTAINER (dialog), 5); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gtk_widget_realize (dialog); gdk_window_set_transient_for (gtk_widget_get_window (GTK_WIDGET (dialog)), gdk_screen_get_root_window (screen)); gtk_window_set_modal (GTK_WINDOW (dialog), TRUE); gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), 14); hbox = gtk_hbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (hbox), 5); gtk_widget_show (hbox); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), hbox, FALSE, FALSE, 0); image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_QUESTION, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0); gtk_widget_show (image); gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0); vbox = gtk_vbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); if (all) { prompt = _("Cannot move items to trash, do you want to delete them immediately?"); detail = g_strdup_printf ("None of the %d selected items can be moved to the Trash", num_files); } else { prompt = _("Cannot move some items to trash, do you want to delete these immediately?"); detail = g_strdup_printf ("%d of the selected items cannot be moved to the Trash", num_files); } str = g_strconcat ("<span weight=\"bold\" size=\"larger\">", prompt, "</span>", NULL); label = gtk_label_new (str); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); g_free (str); label = gtk_label_new (detail); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); g_free (detail); gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_DELETE, GTK_RESPONSE_YES); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_YES); response = gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (GTK_WIDGET (dialog)); return response == GTK_RESPONSE_YES; }
void pragha_filter_dialog (PraghaApplication *pragha) { PraghaPlaylist *playlist; PraghaPreferences *preferences; GtkWidget *dialog, *scrollwin, *vbox, *search_entry; GtkWidget *filter_view = NULL; GtkListStore *filter_store; GtkTreeModel *filter_model; GtkCellRenderer *renderer; GtkTreeViewColumn *column; PraghaFilterDialog *fdialog; fdialog = g_slice_new0(PraghaFilterDialog); playlist = pragha_application_get_playlist (pragha); preferences = pragha_application_get_preferences (pragha); /* Crete the filter entry */ search_entry = pragha_search_entry_new(preferences); g_signal_connect (G_OBJECT(search_entry), "changed", G_CALLBACK(simple_filter_search_keyrelease_handler), fdialog); g_signal_connect (G_OBJECT(search_entry), "activate", G_CALLBACK(simple_filter_search_activate_handler), fdialog); /* Create the view */ filter_store = gtk_list_store_new (2, G_TYPE_UINT, G_TYPE_STRING); column = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "text", 0, NULL); gtk_tree_view_column_set_spacing (column, 4); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "markup", 1, NULL); gtk_tree_view_column_set_spacing (column, 4); /* Fill the filter tree view with current playlist */ pragha_filter_dialog_fill_model (filter_store, playlist); filter_model = gtk_tree_model_filter_new(GTK_TREE_MODEL(filter_store), NULL); g_object_unref(filter_store); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(filter_model), (GtkTreeModelFilterVisibleFunc)filter_model_visible_func, fdialog, NULL); /* Create the tree view */ filter_view = gtk_tree_view_new_with_model(filter_model); gtk_tree_view_append_column (GTK_TREE_VIEW(filter_view), column); g_object_unref(G_OBJECT(filter_model)); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW(filter_view), TRUE); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(filter_view), FALSE); gtk_tree_view_set_enable_search (GTK_TREE_VIEW(filter_view), FALSE); /* Store references */ fdialog->filter_view = filter_view; fdialog->filter_model = filter_model; fdialog->filter_string = NULL; fdialog->timeout_id = 0; fdialog->cplaylist = playlist; fdialog->preferences = pragha_preferences_get(); /* The search dialog */ dialog = gtk_dialog_new_with_buttons (_("Search in playlist"), GTK_WINDOW(pragha_application_get_window(pragha)), GTK_DIALOG_MODAL, GTK_STOCK_CLOSE, GTK_RESPONSE_CANCEL, NULL); gtk_dialog_add_button (GTK_DIALOG (dialog), _("Add to playback queue"), GTK_RESPONSE_ACCEPT); gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_JUMP_TO, GTK_RESPONSE_APPLY); gtk_window_set_default_size (GTK_WINDOW (dialog), 600, 500); /* Add to the dialog's main vbox */ vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog)); gtk_box_pack_start (GTK_BOX(vbox), search_entry, FALSE, FALSE, 3); scrollwin = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER(scrollwin), filter_view); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(scrollwin), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX(vbox), scrollwin, TRUE, TRUE, 0); /* Connect signals */ g_signal_connect (filter_view, "row-activated", G_CALLBACK(pragha_filter_dialog_activated_cb), dialog); g_signal_connect (filter_view, "key_press_event", G_CALLBACK (pragha_filter_dialog_key_press), fdialog); g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(pragha_filter_dialog_response), fdialog); gtk_widget_show_all (dialog); }
static void _really_move_to_trash (CheeseWindow *cheese_window, GList *files) { GError *error = NULL; GList *l = NULL; GList *d = NULL; gchar *primary, *secondary; GtkWidget *question_dialog; gint response; gint list_length = g_list_length (files); g_print ("received %d items to delete\n", list_length); for (l = files; l != NULL; l = l->next) { if (!g_file_test (g_file_get_path (l->data), G_FILE_TEST_EXISTS)) { g_object_unref (l->data); break; } if (!g_file_trash (l->data, NULL, &error)) { primary = g_strdup (_("Cannot move file to trash, do you want to delete immediately?")); secondary = g_strdup_printf (_("The file \"%s\" cannot be moved to the trash. Details: %s"), g_file_get_basename (l->data), error->message); question_dialog = gtk_message_dialog_new (GTK_WINDOW (cheese_window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, "%s", primary); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (question_dialog), "%s", secondary); gtk_dialog_add_button (GTK_DIALOG (question_dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); if (list_length > 1) { /* no need for all those buttons we have a single file to delete */ gtk_dialog_add_button (GTK_DIALOG (question_dialog), CHEESE_BUTTON_SKIP, CHEESE_RESPONSE_SKIP); gtk_dialog_add_button (GTK_DIALOG (question_dialog), CHEESE_BUTTON_SKIP_ALL, CHEESE_RESPONSE_SKIP_ALL); gtk_dialog_add_button (GTK_DIALOG (question_dialog), CHEESE_BUTTON_DELETE_ALL, CHEESE_RESPONSE_DELETE_ALL); } gtk_dialog_add_button (GTK_DIALOG (question_dialog), GTK_STOCK_DELETE, GTK_RESPONSE_ACCEPT); response = gtk_dialog_run (GTK_DIALOG (question_dialog)); gtk_widget_destroy (question_dialog); g_free (primary); g_free (secondary); g_error_free (error); error = NULL; switch (response) { case CHEESE_RESPONSE_DELETE_ALL: /* forward the list to cmd_delete */ _really_delete (cheese_window, l, TRUE); return; case GTK_RESPONSE_ACCEPT: /* create a single file list for cmd_delete */ d = g_list_append (d, g_object_ref (l->data)); _really_delete (cheese_window, d, TRUE); g_list_free (d); break; case CHEESE_RESPONSE_SKIP: /* do nothing, skip to the next item */ break; case CHEESE_RESPONSE_SKIP_ALL: case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_DELETE_EVENT: default: /* cancel the whole delete operation */ return; } } else { cheese_thumb_view_remove_item (cheese_window_get_thumbview (cheese_window), l->data); } g_object_unref (l->data); } }
extern void create_create_popup(GtkAction *action, gpointer user_data) { GtkWidget *popup = gtk_dialog_new_with_buttons( "Create", GTK_WINDOW(user_data), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, NULL); int i, response = 0; GtkWidget *label = NULL; GtkWidget *entry = NULL; GtkTreeModel *model = NULL; GtkTreeIter iter; const gchar *name = gtk_action_get_name(action); sview_search_info_t sview_search_info; job_desc_msg_t *job_msg = NULL; submit_response_msg_t *slurm_alloc_msg = NULL; update_part_msg_t *part_msg = NULL; resv_desc_msg_t *resv_msg = NULL; char *res_name, *temp; sview_search_info.gchar_data = NULL; sview_search_info.int_data = NO_VAL; sview_search_info.int_data2 = NO_VAL; label = gtk_dialog_add_button(GTK_DIALOG(popup), GTK_STOCK_OK, GTK_RESPONSE_OK); gtk_window_set_default(GTK_WINDOW(popup), label); gtk_dialog_add_button(GTK_DIALOG(popup), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); gtk_window_set_default_size(GTK_WINDOW(popup), 400, 600); if (!strcmp(name, "batch_job")) { sview_search_info.search_type = CREATE_BATCH_JOB; entry = create_entry(); label = gtk_label_new( "Batch job submission specifications\n\n" "Specify size (task and/or node count) plus the\n" "script. All other fields are optional.\n\n" "More fields will be made available later."); job_msg = xmalloc(sizeof(job_desc_msg_t)); slurm_init_job_desc_msg(job_msg); job_msg->group_id = getgid(); job_msg->user_id = getuid(); job_msg->work_dir = xmalloc(1024); if (!getcwd(job_msg->work_dir, 1024)) goto end_it; entry = create_job_entry(job_msg, model, &iter); } else if (!strcmp(name, "partition")) { sview_search_info.search_type = CREATE_PARTITION; entry = create_entry(); label = gtk_label_new( "Partition creation specifications\n\n" "Specify Name. All other fields are optional."); part_msg = xmalloc(sizeof(update_part_msg_t)); slurm_init_part_desc_msg(part_msg); entry = create_part_entry(part_msg, model, &iter); } else if (!strcmp(name, "reservation")) { sview_search_info.search_type = CREATE_RESERVATION; label = gtk_label_new( "Reservation creation specifications\n\n" "Specify Time_Start and either Duration or Time_End.\n" #ifdef HAVE_BG "Specify either Node_Count or Midplane_List.\n" #else "Specify either Node_Count or Node_List.\n" #endif "Specify either Accounts or Users.\n\n" "Supported Flags include: Maintenance, Overlap,\n" "Ignore_Jobs, Daily and Weekly, License_Only\n" "Part_Nodes and Static_Alloc.\n" "All other fields are optional."); resv_msg = xmalloc(sizeof(resv_desc_msg_t)); slurm_init_resv_desc_msg(resv_msg); entry = create_resv_entry(resv_msg, model, &iter); } else { sview_search_info.search_type = 0; goto end_it; } gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox), label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox), entry, TRUE, TRUE, 0); gtk_widget_show_all(popup); response = gtk_dialog_run (GTK_DIALOG(popup)); if (response == GTK_RESPONSE_OK) { if (!sview_search_info.search_type) goto end_it; switch(sview_search_info.search_type) { case CREATE_BATCH_JOB: response = slurm_submit_batch_job(job_msg, &slurm_alloc_msg); if (response == SLURM_SUCCESS) { temp = g_strdup_printf( "Job %u submitted", slurm_alloc_msg->job_id); } else { temp = g_strdup_printf( "Problem submitting job: %s", slurm_strerror(slurm_get_errno())); } display_edit_note(temp); g_free(temp); break; case CREATE_PARTITION: response = slurm_create_partition(part_msg); if (response == SLURM_SUCCESS) { temp = g_strdup_printf("Partition %s created", part_msg->name); } else { temp = g_strdup_printf( "Problem creating partition: %s", slurm_strerror(slurm_get_errno())); } display_edit_note(temp); g_free(temp); break; case CREATE_RESERVATION: res_name = slurm_create_reservation(resv_msg); if (res_name) { temp = g_strdup_printf( "Reservation %s created", res_name); free(res_name); } else { temp = g_strdup_printf( "Problem creating reservation: %s", slurm_strerror(slurm_get_errno())); } display_edit_note(temp); g_free(temp); break; default: break; } } end_it: gtk_widget_destroy(popup); if (slurm_alloc_msg) slurm_free_submit_response_response_msg(slurm_alloc_msg); if (job_msg) { for (i = 0; i < job_msg->argc; i++) xfree(job_msg->argv[i]); xfree(job_msg->argv); xfree(job_msg->name); xfree(job_msg->script); xfree(job_msg->work_dir); xfree(job_msg); } xfree(part_msg); if (resv_msg) slurm_free_resv_desc_msg(resv_msg); return; }
void cheese_cmd_file_move_all_to_trash (GtkWidget *widget, CheeseWindow *cheese_window) { GtkWidget *dlg; char *prompt; int response; char *filename; GFile *file; GList *files_list = NULL; GDir *dir_videos, *dir_photos; char *path_videos, *path_photos; const char *name; prompt = g_strdup_printf (_("Really move all photos and videos to the trash?")); dlg = gtk_message_dialog_new_with_markup (GTK_WINDOW (cheese_window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE, "<span weight=\"bold\" size=\"larger\">%s</span>", prompt); g_free (prompt); gtk_dialog_add_button (GTK_DIALOG (dlg), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); gtk_dialog_add_button (GTK_DIALOG (dlg), _("_Move to Trash"), GTK_RESPONSE_OK); gtk_dialog_set_default_response (GTK_DIALOG (dlg), GTK_RESPONSE_OK); gtk_window_set_title (GTK_WINDOW (dlg), ""); gtk_widget_show_all (dlg); response = gtk_dialog_run (GTK_DIALOG (dlg)); gtk_widget_destroy (dlg); if (response != GTK_RESPONSE_OK) return; /* append all videos */ path_videos = cheese_fileutil_get_video_path (cheese_window_get_fileutil (cheese_window)); dir_videos = g_dir_open (path_videos, 0, NULL); while ((name = g_dir_read_name (dir_videos)) != NULL) { if (g_str_has_suffix (name, VIDEO_NAME_SUFFIX)) { filename = g_strjoin (G_DIR_SEPARATOR_S, path_videos, name, NULL); file = g_file_new_for_path (filename); files_list = g_list_append (files_list, file); g_free (filename); } } g_dir_close (dir_videos); /* append all photos */ path_photos = cheese_fileutil_get_photo_path (cheese_window_get_fileutil (cheese_window)); dir_photos = g_dir_open (path_photos, 0, NULL); while ((name = g_dir_read_name (dir_photos)) != NULL) { if (g_str_has_suffix (name, PHOTO_NAME_SUFFIX)) { filename = g_strjoin (G_DIR_SEPARATOR_S, path_photos, name, NULL); file = g_file_new_for_path (filename); files_list = g_list_append (files_list, file); g_free (filename); } } /* delete all items */ _really_move_to_trash (cheese_window, files_list); g_list_free (files_list); g_dir_close (dir_photos); }
extern void change_refresh_popup(GtkAction *action, gpointer user_data) { GtkWidget *table = gtk_table_new(1, 2, FALSE); GtkWidget *label = NULL; GtkObject *adjustment = gtk_adjustment_new( working_sview_config.refresh_delay, 1, 10000, 5, 60, 0); GtkWidget *spin_button = gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1, 0); GtkWidget *popup = gtk_dialog_new_with_buttons( "Refresh Interval", GTK_WINDOW (user_data), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, NULL); GError *error = NULL; int response = 0; char *temp = NULL; label = gtk_dialog_add_button(GTK_DIALOG(popup), GTK_STOCK_OK, GTK_RESPONSE_OK); gtk_window_set_default(GTK_WINDOW(popup), label); gtk_dialog_add_button(GTK_DIALOG(popup), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); label = gtk_label_new("Interval in Seconds "); gtk_container_set_border_width(GTK_CONTAINER(table), 10); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox), table, FALSE, FALSE, 0); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1); gtk_table_attach_defaults(GTK_TABLE(table), spin_button, 1, 2, 0, 1); gtk_widget_show_all(popup); response = gtk_dialog_run (GTK_DIALOG(popup)); if (response == GTK_RESPONSE_OK) { working_sview_config.refresh_delay = gtk_spin_button_get_value_as_int( GTK_SPIN_BUTTON(spin_button)); temp = g_strdup_printf("Refresh Interval set to %d seconds.", working_sview_config.refresh_delay); gtk_statusbar_pop(GTK_STATUSBAR(main_statusbar), STATUS_REFRESH); response = gtk_statusbar_push(GTK_STATUSBAR(main_statusbar), STATUS_REFRESH, temp); g_free(temp); if (!sview_thread_new(_refresh_thr, GINT_TO_POINTER(response), FALSE, &error)) { g_printerr ("Failed to create refresh thread: %s\n", error->message); } } gtk_widget_destroy(popup); return; }
static void delete_button_clicked (GtkWidget *button, GtrPreferencesDialog *dlg) { GtkTreeIter iter; GtkTreeModel *model; GtkTreeSelection *selection; gboolean active; GtkWidget *dialog; gchar *markup; model = gtk_tree_view_get_model (GTK_TREE_VIEW (dlg->priv->profile_treeview)); g_return_if_fail (model != NULL); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dlg->priv->profile_treeview)); if (gtk_tree_selection_get_selected (selection, &model, &iter)) { gtk_tree_model_get (model, &iter, ACTIVE_PROFILE_COLUMN, &active, -1); if (active) { dialog = gtk_message_dialog_new (GTK_WINDOW (dlg), GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, NULL); markup = g_strdup_printf("<span weight=\"bold\" size=\"large\">%s</span>", _("Impossible to remove the active profile")); gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (dialog), markup); g_free(markup); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), _("Another profile should be selected as active before")); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); } else { dialog = gtk_message_dialog_new (GTK_WINDOW (dlg), GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, NULL); markup = g_strdup_printf("<span weight=\"bold\" size=\"large\">%s</span>", _("Are you sure you want to delete this profile?")); gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (dialog), markup); g_free(markup); gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_DELETE, GTK_RESPONSE_YES); gtk_dialog_run (GTK_DIALOG (dialog)); g_signal_connect (GTK_DIALOG (dialog), "response", G_CALLBACK (delete_confirm_dialog_cb), dlg); } } }
static void marlin_file_conflict_dialog_init (MarlinFileConflictDialog *fcd) { GtkWidget *hbox, *vbox, *vbox2, *alignment; GtkWidget *widget, *dialog_area; MarlinFileConflictDialogDetails *details; GtkDialog *dialog; details = fcd->details = MARLIN_FILE_CONFLICT_DIALOG_GET_PRIVATE (fcd); dialog = GTK_DIALOG (fcd); /* Setup the main hbox */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); dialog_area = gtk_dialog_get_content_area (dialog); gtk_box_pack_start (GTK_BOX (dialog_area), hbox, FALSE, FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (hbox), 6); /* Setup the dialog image */ widget = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_DIALOG); gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0); gtk_misc_set_alignment (GTK_MISC (widget), 0.5, 0.0); /* Setup the vbox containing the dialog body */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); /* Setup the vbox for the dialog labels */ widget = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0); details->titles_vbox = widget; /* Setup the hboxes to pack file infos into */ alignment = gtk_alignment_new (0.0, 0.0, 0.0, 0.0); g_object_set (alignment, "left-padding", 12, NULL); vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_container_add (GTK_CONTAINER (alignment), vbox2); gtk_box_pack_start (GTK_BOX (vbox), alignment, FALSE, FALSE, 0); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0); details->first_hbox = hbox; hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0); details->second_hbox = hbox; /* Setup the expander for the rename action */ details->expander = gtk_expander_new_with_mnemonic (_("_Select a new name for the destination")); gtk_box_pack_start (GTK_BOX (vbox2), details->expander, FALSE, FALSE, 0); g_signal_connect (details->expander, "activate", G_CALLBACK (expander_activated_cb), dialog); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_container_add (GTK_CONTAINER (details->expander), hbox); widget = gtk_entry_new (); gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 6); details->entry = widget; g_signal_connect (widget, "changed", G_CALLBACK (entry_text_changed_cb), dialog); widget = gtk_button_new_with_label (_("Reset")); gtk_button_set_image (GTK_BUTTON (widget), gtk_image_new_from_stock (GTK_STOCK_UNDO, GTK_ICON_SIZE_MENU)); gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 6); g_signal_connect (widget, "clicked", G_CALLBACK (reset_button_clicked_cb), dialog); gtk_widget_show_all (alignment); /* Setup the checkbox to apply the action to all files */ widget = gtk_check_button_new_with_mnemonic (_("Apply this action to all files")); gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0); details->checkbox = widget; g_signal_connect (widget, "toggled", G_CALLBACK (checkbox_toggled_cb), dialog); /* Add buttons */ gtk_dialog_add_buttons (dialog, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, _("_Skip"), CONFLICT_RESPONSE_SKIP, NULL); details->rename_button = gtk_dialog_add_button (dialog, _("Re_name"), CONFLICT_RESPONSE_RENAME); gtk_widget_hide (details->rename_button); details->replace_button = gtk_dialog_add_button (dialog, _("Replace"), CONFLICT_RESPONSE_REPLACE); gtk_widget_grab_focus (details->replace_button); /* Setup HIG properties */ gtk_container_set_border_width (GTK_CONTAINER (dialog), 5); gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (dialog)), 14); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gtk_widget_show_all (dialog_area); }
int sample_selector_show(int id, GtkWidget* parent_window, SampleTab* sampletab) { enum { RESPONSE_LOAD = 1, RESPONSE_PREVIEW = 2 }; GtkWidget* dialog; raw_box* rawbox; global_settings* settings = settings_get(); last_sample = sample_new(); patch = id; dialog = gtk_file_chooser_dialog_new("Load Sample", GTK_WINDOW(parent_window), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); if ((rawbox = raw_box_new(dialog))) { gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(dialog), rawbox->box); } create_filters(dialog); sample_shallow_copy(last_sample, patch_sample_data(patch)); if (last_sample->filename && strcmp(last_sample->filename, "Default") != 0) { gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), last_sample->filename); gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), g_path_get_dirname(last_sample->filename)); } else { if ( settings->last_sample_dir) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), settings->last_sample_dir); } gtk_dialog_add_button(GTK_DIALOG(dialog), "Loa_d", RESPONSE_LOAD); gtk_dialog_add_button(GTK_DIALOG(dialog), "Pre_view", RESPONSE_PREVIEW); /* we don't always want to auto-preview when the "selection-changed" signal is emitted on a) when the dialog is created, b) when the current-folder is changed. */ rawbox->dont_preview = true; g_timeout_add(250, timeout_cancel_dont_preview, rawbox); g_signal_connect(rawbox->dialog, "current-folder-changed", G_CALLBACK(folder_changed_cb), rawbox); g_signal_connect(rawbox->dialog, "selection-changed", G_CALLBACK(selection_changed_cb), rawbox); again: switch(gtk_dialog_run(GTK_DIALOG(dialog))) { case GTK_RESPONSE_ACCEPT: cb_load(rawbox); break; case RESPONSE_LOAD: cb_load(rawbox); sample_tab_update_waveforms(sampletab); goto again; case RESPONSE_PREVIEW: cb_preview(rawbox); goto again; case GTK_RESPONSE_CANCEL: cb_cancel(); default: break; } gtk_widget_destroy(dialog); sample_free(last_sample); last_sample = 0; return 0; }
static GtkWidget *create_dialog(void) { GtkWidget *dialog; GtkWidget *header_image; GtkWidget *header_label; GtkWidget *label_info; GtkWidget *codename_label; GtkWidget *builddate_label; GtkWidget *url_button; GtkWidget *cop_label; GtkWidget *label; GtkWidget *license_textview; GtkWidget *notebook; GtkWidget *box; GtkWidget *credits_scrollwin; GtkWidget *table; GtkWidget *license_scrollwin; GtkWidget *info_box; GtkWidget *header_hbox; GtkWidget *header_eventbox; GdkPixbuf *icon; GtkTextBuffer* tb; gchar *license_text = NULL; gchar buffer[512]; gchar buffer2[128]; guint i, row = 0; dialog = gtk_dialog_new(); /* configure dialog */ gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(main_widgets.window)); gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_title(GTK_WINDOW(dialog), _("About Geany")); gtk_widget_set_name(dialog, "GeanyDialog"); gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE); gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); g_signal_connect(dialog, "key-press-event", G_CALLBACK(gb_on_key_pressed), NULL); /* create header */ header_eventbox = gtk_event_box_new(); gtk_widget_show(header_eventbox); header_hbox = gtk_hbox_new(FALSE, 12); gtk_container_set_border_width(GTK_CONTAINER(header_hbox), 4); gtk_widget_show(header_hbox); gtk_container_add(GTK_CONTAINER(header_eventbox), header_hbox); header_image = gtk_image_new(); gtk_box_pack_start(GTK_BOX(header_hbox), header_image, FALSE, FALSE, 0); header_label = gtk_label_new(NULL); gtk_label_set_use_markup(GTK_LABEL(header_label), TRUE); /* print the subversion revision generated by ./configure if it is available */ g_snprintf(buffer, sizeof(buffer), HEADER, main_get_version_string()); gtk_label_set_markup(GTK_LABEL(header_label), buffer); gtk_widget_show(header_label); gtk_box_pack_start(GTK_BOX(header_hbox), header_label, FALSE, FALSE, 0); header_eventbox_style_set(header_eventbox); header_label_style_set(header_label); g_signal_connect_after(header_eventbox, "style-set", G_CALLBACK(header_eventbox_style_set), NULL); g_signal_connect_after(header_label, "style-set", G_CALLBACK(header_label_style_set), NULL); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), header_eventbox, FALSE, FALSE, 0); /* set image */ icon = ui_new_pixbuf_from_inline(GEANY_IMAGE_LOGO); gtk_image_set_from_pixbuf(GTK_IMAGE(header_image), icon); gtk_window_set_icon(GTK_WINDOW(dialog), icon); g_object_unref(icon); /* free our reference */ /* create notebook */ notebook = gtk_notebook_new(); gtk_widget_show(notebook); gtk_container_set_border_width(GTK_CONTAINER(notebook), 2); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), notebook, TRUE, TRUE, 0); /* create "Info" tab */ info_box = gtk_vbox_new(FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(info_box), 6); gtk_widget_show(info_box); label_info = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(label_info), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(label_info), TRUE); gtk_label_set_use_markup(GTK_LABEL(label_info), TRUE); g_snprintf(buffer, sizeof(buffer), INFO, _("A fast and lightweight IDE")); gtk_label_set_markup(GTK_LABEL(label_info), buffer); gtk_misc_set_padding(GTK_MISC(label_info), 2, 11); gtk_widget_show(label_info); gtk_box_pack_start(GTK_BOX(info_box), label_info, FALSE, FALSE, 0); /* Codename label */ codename_label = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(codename_label), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(codename_label), TRUE); gtk_label_set_use_markup(GTK_LABEL(codename_label), TRUE); gtk_label_set_markup(GTK_LABEL(codename_label), CODENAME); gtk_misc_set_padding(GTK_MISC(codename_label), 2, 8); gtk_widget_show(codename_label); gtk_box_pack_start(GTK_BOX(info_box), codename_label, FALSE, FALSE, 0); /* build date label */ builddate_label = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(builddate_label), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(builddate_label), TRUE); gtk_label_set_use_markup(GTK_LABEL(builddate_label), TRUE); g_snprintf(buffer2, sizeof(buffer2), _("(built on or after %s)"), __DATE__); g_snprintf(buffer, sizeof(buffer), BUILDDATE, buffer2); gtk_label_set_markup(GTK_LABEL(builddate_label), buffer); gtk_misc_set_padding(GTK_MISC(builddate_label), 2, 2); gtk_widget_show(builddate_label); gtk_box_pack_start(GTK_BOX(info_box), builddate_label, FALSE, FALSE, 0); box = gtk_hbutton_box_new(); url_button = gtk_button_new(); gtk_button_set_relief(GTK_BUTTON(url_button), GTK_RELIEF_NONE); g_signal_connect(url_button, "clicked", G_CALLBACK(homepage_clicked), (gpointer)GEANY_HOMEPAGE); label = gtk_label_new(NULL); gtk_label_set_text(GTK_LABEL(label), GEANY_HOMEPAGE); gtk_widget_show(label); gtk_container_add(GTK_CONTAINER(url_button), label); gtk_widget_show(url_button); gtk_box_pack_start(GTK_BOX(box), url_button, FALSE, FALSE, 0); gtk_widget_show(box); gtk_box_pack_start(GTK_BOX(info_box), box, FALSE, FALSE, 10); /* copyright label */ cop_label = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(cop_label), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(cop_label), FALSE); gtk_label_set_use_markup(GTK_LABEL(cop_label), TRUE); gtk_label_set_markup(GTK_LABEL(cop_label), COPYRIGHT); gtk_misc_set_padding(GTK_MISC(cop_label), 2, 10); gtk_widget_show(cop_label); gtk_box_pack_start(GTK_BOX(info_box), cop_label, FALSE, FALSE, 0); /*gtk_container_add(GTK_CONTAINER(info_box), cop_label); */ label = gtk_label_new(_("Info")); gtk_widget_show(label); gtk_widget_show_all(info_box); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), info_box, label); /* create "Credits" tab */ credits_scrollwin = gtk_scrolled_window_new(NULL, NULL); gtk_container_set_border_width(GTK_CONTAINER(credits_scrollwin), 6); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(credits_scrollwin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); table = gtk_table_new(23 + translators_len + prev_translators_len, 3, FALSE); gtk_table_set_col_spacings(GTK_TABLE(table), 10); row = 0; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Developers")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, GTK_FILL, 0, 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Colomban Wendling - %s", _("maintainer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Nick Treleaven - %s", _("developer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Enrico Tröger - %s", _("developer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Matthew Brush - %s", _("developer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Frank Lanitz - %s", _("translation maintainer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Translators")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; for (i = 0; i < translators_len; i++) { ROW(translators[i][0], row, 0, 1, 4, 0); ROW(translators[i][1], row, 1, 0, 4, 0); row++; } ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Previous Translators")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; for (i = 0; i < prev_translators_len; i++) { ROW(prev_translators[i][0], row, 0, 1, 4, 0); ROW(prev_translators[i][1], row, 1, 0, 4, 0); row++; } ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Contributors")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; g_snprintf(buffer, sizeof(buffer), _("Some of the many contributors (for a more detailed list, see the file %s):"), #ifdef G_OS_WIN32 "Thanks.txt" #else "THANKS" #endif ); label = geany_wrap_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; label = geany_wrap_label_new(contributors); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL | GTK_EXPAND), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(credits_scrollwin), table); gtk_viewport_set_shadow_type(GTK_VIEWPORT(gtk_widget_get_parent(table)), GTK_SHADOW_NONE); gtk_widget_show_all(table); label = gtk_label_new(_("Credits")); gtk_widget_show(label); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), credits_scrollwin, label); /* create "License" tab */ license_scrollwin = gtk_scrolled_window_new(NULL, NULL); gtk_container_set_border_width(GTK_CONTAINER(license_scrollwin), 6); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(license_scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(license_scrollwin), GTK_SHADOW_IN); license_textview = gtk_text_view_new(); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(license_textview), 2); gtk_text_view_set_right_margin(GTK_TEXT_VIEW(license_textview), 2); gtk_text_view_set_editable(GTK_TEXT_VIEW(license_textview), FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(license_textview), FALSE); gtk_widget_show(license_textview); gtk_container_add(GTK_CONTAINER(license_scrollwin), license_textview); label = gtk_label_new(_("License")); gtk_widget_show(label); g_snprintf(buffer, sizeof(buffer), "%s" G_DIR_SEPARATOR_S "GPL-2", app->datadir); g_file_get_contents(buffer, &license_text, NULL, NULL); if (license_text == NULL) { license_text = g_strdup( _("License text could not be found, please visit http://www.gnu.org/licenses/gpl-2.0.txt to view it online.")); } tb = gtk_text_view_get_buffer(GTK_TEXT_VIEW(license_textview)); gtk_text_buffer_set_text(tb, license_text, -1); g_free(license_text); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), license_scrollwin, label); gtk_widget_show_all(dialog); return dialog; }
static void _setup_ui (OlPlayerChooser *window) { OlPlayerChooserPrivate *priv = OL_PLAYER_CHOOSER_GET_PRIVATE (window); /* Setup info widgets */ priv->info_label = GTK_LABEL (gtk_label_new (NULL)); gtk_label_set_line_wrap (priv->info_label, TRUE); gtk_misc_set_alignment (GTK_MISC (priv->info_label), 0.0, 0.0); priv->info_icon = GTK_IMAGE (gtk_image_new_from_stock (GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG)); GtkWidget *info_box = gtk_hbox_new (FALSE, 10); gtk_box_pack_start (GTK_BOX (info_box), GTK_WIDGET (priv->info_icon), FALSE, /* expand */ FALSE, /* fill */ 0); gtk_box_pack_start (GTK_BOX (info_box), GTK_WIDGET (priv->info_label), TRUE, /* expand */ TRUE, /* fill */ 0); /* Setup app choosers */ priv->page_button_panel = GTK_BOX (gtk_hbox_new (FALSE, 0)); priv->chooser_panel = GTK_BOX (gtk_hbox_new (FALSE, 0)); _new_page (window, _("Supported players")); _new_page (window, _("All players")); _set_apps_to_page (window, ALL_CHOOSER_INDEX, g_app_info_get_all_for_type ("audio/mp3")); GtkWidget *apps_frame = gtk_frame_new (_("Choose a player to launch")); GtkBox *page_vbox = GTK_BOX (gtk_vbox_new (FALSE, 0)); gtk_widget_show (GTK_WIDGET (page_vbox)); gtk_box_pack_start (page_vbox, GTK_WIDGET (priv->page_button_panel), FALSE, /* expand */ FALSE, /* fill */ 0); /* padding */ gtk_box_pack_end (page_vbox, GTK_WIDGET (priv->chooser_panel), FALSE, /* expand */ FALSE, /* fill */ 0); /* padding */ gtk_container_add (GTK_CONTAINER (apps_frame), GTK_WIDGET (page_vbox)); /* Setup custom command */ priv->custom_cmd_panel = GTK_BOX (gtk_hbox_new (FALSE, 5)); GtkWidget *cmd_label = gtk_label_new (_("Use command:")); GtkWidget *cmd_entry = gtk_entry_new (); priv->cmd_entry = GTK_ENTRY (cmd_entry); gtk_entry_set_activates_default (priv->cmd_entry, TRUE); gtk_entry_set_completion (priv->cmd_entry, _new_bin_completion ()); GtkWidget *launch_button = gtk_button_new_with_label (_("Launch")); gtk_widget_set_can_default (launch_button, TRUE); gtk_window_set_default (GTK_WINDOW (window), launch_button); priv->launch_button = launch_button; g_signal_connect (launch_button, "clicked", G_CALLBACK (_launch_button_clicked_cb), window); gtk_box_pack_start (priv->custom_cmd_panel, cmd_label, FALSE, TRUE, 0); gtk_box_pack_start (priv->custom_cmd_panel, cmd_entry, TRUE, TRUE, 0); gtk_box_pack_start (priv->custom_cmd_panel, launch_button, FALSE, TRUE, 0); GtkWidget *final_hbox = gtk_hbox_new (FALSE, 0); GtkWidget *remember_button = gtk_check_button_new_with_label (_("Remember my choice")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (remember_button), TRUE); priv->remember_button = remember_button; gtk_box_pack_start (GTK_BOX (final_hbox), remember_button, FALSE, TRUE, 0); /* Setup the whole dialog */ GtkWidget *vbox = gtk_dialog_get_content_area (GTK_DIALOG (window)); gtk_box_set_spacing (GTK_BOX (vbox), 10); gtk_box_pack_start (GTK_BOX (vbox), info_box, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), apps_frame, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (priv->custom_cmd_panel), FALSE, TRUE, 0); gtk_box_pack_end (GTK_BOX (vbox), final_hbox, FALSE, TRUE, 0); gtk_widget_show (vbox); gtk_widget_show_all (info_box); gtk_widget_show (apps_frame); gtk_widget_show_all (GTK_WIDGET (priv->page_button_panel)); gtk_widget_show (GTK_WIDGET (priv->chooser_panel)); gtk_widget_show_all (GTK_WIDGET (priv->custom_cmd_panel)); gtk_widget_show_all (GTK_WIDGET (final_hbox)); gtk_dialog_add_button (GTK_DIALOG (window), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); gtk_window_set_title (GTK_WINDOW (window), _("Choose a player to launch")); gtk_window_set_resizable (GTK_WINDOW (window), FALSE); gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER); }