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);
}
