static gboolean
level_dialog(LevelArgs *args,
const gchar *title)
{
enum { RESPONSE_RESET = 1 };
GtkWidget *dialog, *label, *table;
gint row, response;
LevelControls controls;
controls.args = args;
dialog = gtk_dialog_new_with_buttons(title, NULL, 0,
_("_Reset"), RESPONSE_RESET,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
gwy_help_add_to_proc_dialog(GTK_DIALOG(dialog), GWY_HELP_DEFAULT);
table = gtk_table_new(4, 3, 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_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), table);
row = 0;
label = gwy_label_new_header(_("Masking Mode"));
gtk_table_attach(GTK_TABLE(table), label,
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
controls.masking = gwy_radio_buttons_create(gwy_masking_type_get_enum(), -1,
G_CALLBACK(masking_changed),
&controls, args->masking);
row = gwy_radio_buttons_attach_to_table(controls.masking, GTK_TABLE(table),
3, row);
gtk_widget_show_all(dialog);
do {
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
gtk_widget_destroy(dialog);
case GTK_RESPONSE_NONE:
return FALSE;
break;
case GTK_RESPONSE_OK:
break;
case RESPONSE_RESET:
*args = level_defaults;
gwy_radio_buttons_set_current(controls.masking, args->masking);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
gtk_widget_destroy(dialog);
return TRUE;
}
static gboolean
entropy_dialog(EntropyArgs *args, GwyDataField *dfield, GwyDataField *mfield)
{
GtkWidget *dialog, *table, *label, *hbox;
GwyGraphModel *gmodel;
EntropyControls controls;
gint response;
gint row;
controls.args = args;
controls.dfield = dfield;
controls.mfield = mfield;
dialog = gtk_dialog_new_with_buttons(_("Entropy"), 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),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
gtk_dialog_add_button(GTK_DIALOG(dialog),
GTK_STOCK_OK, GTK_RESPONSE_OK);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
gwy_help_add_to_proc_dialog(GTK_DIALOG(dialog), GWY_HELP_DEFAULT);
controls.dialog = dialog;
hbox = gtk_hbox_new(FALSE, 12);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox,
TRUE, TRUE, 0);
table = gtk_table_new(8 + 4*(!!mfield), 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, 0);
row = 0;
controls.mode
= gwy_radio_buttons_createl(G_CALLBACK(mode_changed), &controls,
args->mode,
_("Value distribution"),
ENTROPY_VALUES,
_("Slope derivative distribution"),
ENTROPY_SLOPES,
_("Slope angle distribution"),
ENTROPY_ANGLES,
NULL);
row = gwy_radio_buttons_attach_to_table(controls.mode,
GTK_TABLE(table), 3, row);
if (mfield) {
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
label = gwy_label_new_header(_("Masking Mode"));
gtk_table_attach(GTK_TABLE(table), label,
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
controls.masking
= gwy_radio_buttons_create(gwy_masking_type_get_enum(), -1,
G_CALLBACK(masking_changed), &controls,
args->masking);
row = gwy_radio_buttons_attach_to_table(controls.masking,
GTK_TABLE(table), 3, row);
}
else
controls.masking = NULL;
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
controls.fit_plane
= gtk_check_button_new_with_mnemonic(_("Use local plane _fitting"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.fit_plane),
args->fit_plane);
gtk_table_attach(GTK_TABLE(table), controls.fit_plane,
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
g_signal_connect_swapped(controls.fit_plane, "toggled",
G_CALLBACK(fit_plane_changed), &controls);
row++;
controls.kernel_size = gtk_adjustment_new(args->kernel_size,
2, 16, 1, 4, 0);
gwy_table_attach_hscale(table, row, _("_Plane size:"), "px",
controls.kernel_size, 0);
g_signal_connect_swapped(controls.kernel_size, "value-changed",
G_CALLBACK(kernel_size_changed), &controls);
row++;
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
controls.zoom_in
= gtk_check_button_new_with_mnemonic(_("_Zoom graph around estimate"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.zoom_in),
args->zoom_in);
gtk_table_attach(GTK_TABLE(table), controls.zoom_in,
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
g_signal_connect_swapped(controls.zoom_in, "toggled",
G_CALLBACK(zoom_in_changed), &controls);
row++;
label = gtk_label_new(_("Entropy:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
label = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
2, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
controls.entropy = label;
row++;
label = gtk_label_new(_("Entropy deficit:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
label = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
2, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
controls.entropydef = label;
row++;
update_sensitivity(&controls);
gmodel = gwy_graph_model_new();
controls.graph = gwy_graph_new(gmodel);
g_object_unref(gmodel);
gtk_widget_set_size_request(controls.graph, 400, 320);
gtk_box_pack_start(GTK_BOX(hbox), controls.graph, TRUE, TRUE, 0);
gtk_widget_show_all(dialog);
do {
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
gtk_widget_destroy(dialog);
case GTK_RESPONSE_NONE:
return FALSE;
break;
case GTK_RESPONSE_OK:
break;
case RESPONSE_PREVIEW:
preview(&controls);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
gtk_widget_destroy(dialog);
return TRUE;
}
static gboolean
immerse_dialog(ImmerseArgs *args)
{
ImmerseControls controls;
GwyContainer *data;
GtkDialog *dialog;
GtkWidget *table, *chooser, *hbox, *alignment, *label, *button, *vbox;
GtkTooltips *tooltips;
GdkDisplay *display;
GwyDataField *dfield;
gint response, row, id;
gboolean ok;
memset(&controls, 0, sizeof(ImmerseControls));
controls.args = args;
tooltips = gwy_app_get_tooltips();
controls.dialog = gtk_dialog_new_with_buttons(_("Immerse Detail"),
NULL, 0, NULL);
dialog = GTK_DIALOG(controls.dialog);
button = gtk_dialog_add_button(dialog, _("_Locate"), RESPONSE_ESTIMATE);
gtk_tooltips_set_tip(tooltips, button,
_("Locate detail by full image correlation search"),
NULL);
button = gtk_dialog_add_button(dialog, _("_Improve"), RESPONSE_REFINE);
gtk_tooltips_set_tip(tooltips, button,
_("Improve detail position by "
"correlation search in neighborhood"), NULL);
gtk_dialog_add_button(dialog, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
gtk_dialog_add_button(dialog, GTK_STOCK_OK, GTK_RESPONSE_OK);
gtk_dialog_set_default_response(dialog, GTK_RESPONSE_OK);
gwy_help_add_to_proc_dialog(GTK_DIALOG(dialog), GWY_HELP_DEFAULT);
hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(dialog->vbox), hbox, FALSE, FALSE, 4);
/* Preview */
data = gwy_app_data_browser_get(args->image.datano);
id = args->image.id;
dfield = gwy_container_get_object(data, gwy_app_get_data_key_for_id(id));
controls.vf
= gwy_data_field_get_value_format_xy(dfield,
GWY_SI_UNIT_FORMAT_VFMARKUP, NULL);
controls.mydata = gwy_container_new();
gwy_container_set_object_by_name(controls.mydata, "/0/data", dfield);
gwy_app_sync_data_items(data, controls.mydata, id, 0, FALSE,
GWY_DATA_ITEM_PALETTE,
GWY_DATA_ITEM_MASK_COLOR,
GWY_DATA_ITEM_RANGE,
0);
gwy_container_set_boolean_by_name(controls.mydata, "/0/data/realsquare",
TRUE);
controls.view = create_preview(controls.mydata, 0, PREVIEW_SIZE, FALSE);
alignment = GTK_WIDGET(gtk_alignment_new(0.5, 0, 0, 0));
gtk_container_add(GTK_CONTAINER(alignment), controls.view);
gtk_box_pack_start(GTK_BOX(hbox), alignment, FALSE, FALSE, 4);
g_signal_connect_after(controls.view, "expose-event",
G_CALLBACK(immerse_view_expose), &controls);
g_signal_connect(controls.view, "button-press-event",
G_CALLBACK(immerse_view_button_press), &controls);
g_signal_connect(controls.view, "button-release-event",
G_CALLBACK(immerse_view_button_release), &controls);
g_signal_connect(controls.view, "motion-notify-event",
G_CALLBACK(immerse_view_motion_notify), &controls);
vbox = gtk_vbox_new(FALSE, 8);
gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 4);
/* Parameters table */
table = gtk_table_new(8, 4, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 6);
gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 4);
row = 0;
/* Detail to immerse */
chooser = gwy_data_chooser_new_channels();
gwy_data_chooser_set_active_id(GWY_DATA_CHOOSER(chooser), &args->detail);
gwy_data_chooser_set_filter(GWY_DATA_CHOOSER(chooser),
immerse_data_filter, &args->image, NULL);
gwy_data_chooser_get_active_id(GWY_DATA_CHOOSER(chooser), &args->detail);
g_signal_connect(chooser, "changed",
G_CALLBACK(immerse_detail_cb), &controls);
gwy_table_attach_hscale(table, row, _("_Detail image:"), NULL,
GTK_OBJECT(chooser), GWY_HSCALE_WIDGET_NO_EXPAND);
row++;
/* Detail position */
label = gtk_label_new(_("Position:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 1, row, row+1, GTK_FILL, 0, 0, 0);
controls.pos = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(controls.pos), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), controls.pos,
1, 3, row, row+1, GTK_FILL, 0, 0, 0);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
/* Sampling */
label = gtk_label_new(_("Result Sampling"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
controls.sampling
= gwy_radio_buttons_createl(G_CALLBACK(immerse_sampling_changed),
&controls,
args->sampling,
_("_Upsample large image"),
GWY_IMMERSE_SAMPLING_UP,
_("_Downsample detail"),
GWY_IMMERSE_SAMPLING_DOWN,
NULL);
row = gwy_radio_buttons_attach_to_table(controls.sampling, GTK_TABLE(table),
4, row);
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
/* Leveling */
label = gtk_label_new(_("Detail Leveling"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
controls.leveling
= gwy_radio_buttons_createl(G_CALLBACK(immerse_leveling_changed),
&controls,
args->leveling,
gwy_sgettext("levelling|_None"),
GWY_IMMERSE_LEVEL_NONE,
_("_Mean value"), GWY_IMMERSE_LEVEL_MEAN,
NULL);
row = gwy_radio_buttons_attach_to_table(controls.leveling, GTK_TABLE(table),
4, row);
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
/* Draw frame */
controls.draw_frame = gtk_check_button_new_with_mnemonic(_("Show _frame"));
gtk_table_attach(GTK_TABLE(table), controls.draw_frame,
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.draw_frame),
args->draw_frame);
g_signal_connect(controls.draw_frame, "toggled",
G_CALLBACK(immerse_frame_toggled), &controls);
gtk_widget_show_all(controls.dialog);
display = gtk_widget_get_display(controls.dialog);
controls.near_cursor = gdk_cursor_new_for_display(display, GDK_FLEUR);
controls.move_cursor = gdk_cursor_new_for_display(display, GDK_CROSS);
immerse_detail_cb(GWY_DATA_CHOOSER(chooser), &controls);
ok = FALSE;
do {
response = gtk_dialog_run(dialog);
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
case GTK_RESPONSE_NONE:
immerse_controls_destroy(&controls);
immerse_save_args(gwy_app_settings_get(), args);
return FALSE;
break;
case RESPONSE_ESTIMATE:
case RESPONSE_REFINE:
immerse_search(&controls, response);
break;
case GTK_RESPONSE_OK:
ok = TRUE;
break;
default:
g_assert_not_reached();
break;
}
} while (!ok);
immerse_controls_destroy(&controls);
immerse_save_args(gwy_app_settings_get(), args);
return TRUE;
}
static gboolean
noise_synth_dialog(NoiseSynthArgs *args,
GwyDimensionArgs *dimsargs,
GwyContainer *data,
GwyDataField *dfield_template,
gint id)
{
GtkWidget *dialog, *table, *vbox, *hbox, *notebook, *label;
NoiseSynthControls controls;
GwyDataField *dfield;
GwyPixmapLayer *layer;
gboolean finished;
gint response;
gint row;
gwy_clear(&controls, 1);
controls.in_init = TRUE;
controls.args = args;
dialog = gtk_dialog_new_with_buttons(_("Random Noise"),
NULL, 0,
_("_Reset"), RESPONSE_RESET,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
gwy_help_add_to_proc_dialog(GTK_DIALOG(dialog), GWY_HELP_DEFAULT);
controls.dialog = dialog;
hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox,
FALSE, FALSE, 4);
vbox = gtk_vbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 4);
controls.mydata = gwy_container_new();
dfield = gwy_data_field_new(PREVIEW_SIZE, PREVIEW_SIZE,
dimsargs->measure*PREVIEW_SIZE,
dimsargs->measure*PREVIEW_SIZE,
TRUE);
gwy_container_set_object_by_name(controls.mydata, "/0/data", dfield);
controls.noise = gwy_data_field_new_alike(dfield, FALSE);
if (dfield_template) {
gwy_app_sync_data_items(data, controls.mydata, id, 0, FALSE,
GWY_DATA_ITEM_PALETTE,
0);
controls.surface = gwy_synth_surface_for_preview(dfield_template,
PREVIEW_SIZE);
controls.zscale = gwy_data_field_get_rms(dfield_template);
}
controls.view = gwy_data_view_new(controls.mydata);
layer = gwy_layer_basic_new();
g_object_set(layer,
"data-key", "/0/data",
"gradient-key", "/0/base/palette",
NULL);
gwy_data_view_set_base_layer(GWY_DATA_VIEW(controls.view), layer);
gtk_box_pack_start(GTK_BOX(vbox), controls.view, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox),
gwy_synth_instant_updates_new(&controls,
&controls.update_now,
&controls.update,
&args->update),
FALSE, FALSE, 0);
g_signal_connect_swapped(controls.update_now, "clicked",
G_CALLBACK(preview), &controls);
gtk_box_pack_start(GTK_BOX(vbox),
gwy_synth_random_seed_new(&controls,
&controls.seed, &args->seed),
FALSE, FALSE, 0);
controls.randomize = gwy_synth_randomize_new(&args->randomize);
gtk_box_pack_start(GTK_BOX(vbox), controls.randomize, FALSE, FALSE, 0);
notebook = gtk_notebook_new();
gtk_box_pack_start(GTK_BOX(hbox), notebook, TRUE, TRUE, 4);
g_signal_connect_swapped(notebook, "switch-page",
G_CALLBACK(page_switched), &controls);
controls.dims = gwy_dimensions_new(dimsargs, dfield_template);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
gwy_dimensions_get_widget(controls.dims),
gtk_label_new(_("Dimensions")));
if (controls.dims->add)
g_signal_connect_swapped(controls.dims->add, "toggled",
G_CALLBACK(noise_synth_invalidate), &controls);
table = gtk_table_new(6 + (dfield_template ? 1 : 0), 4, FALSE);
controls.table = GTK_TABLE(table);
gtk_table_set_row_spacings(controls.table, 2);
gtk_table_set_col_spacings(controls.table, 6);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), table,
gtk_label_new(_("Generator")));
row = 0;
controls.distribution = distribution_selector_new(&controls);
gwy_table_attach_hscale(table, row, _("_Distribution:"), NULL,
GTK_OBJECT(controls.distribution),
GWY_HSCALE_WIDGET);
row++;
label = gtk_label_new(_("Direction:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, row, row+1,
GTK_FILL, 0, 0, 0);
row++;
controls.direction
= gwy_radio_buttons_createl(G_CALLBACK(direction_type_changed),
&controls, args->direction,
_("S_ymmetrical"), NOISE_DIRECTION_BOTH,
_("One-sided _positive"), NOISE_DIRECTION_UP,
_("One-sided _negative"), NOISE_DIRECTION_DOWN,
NULL);
row = gwy_radio_buttons_attach_to_table(controls.direction,
GTK_TABLE(table), 3, row);
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
row = gwy_synth_attach_height(&controls, row,
&controls.sigma, &args->sigma,
_("_RMS:"), NULL, &controls.sigma_units);
if (dfield_template) {
controls.sigma_init
= gtk_button_new_with_mnemonic(_("_Like Current Channel"));
g_signal_connect_swapped(controls.sigma_init, "clicked",
G_CALLBACK(sigma_init_clicked), &controls);
gtk_table_attach(GTK_TABLE(table), controls.sigma_init,
1, 3, row, row+1, GTK_FILL, 0, 0, 0);
row++;
}
gtk_widget_show_all(dialog);
controls.in_init = FALSE;
/* Must be done when widgets are shown, see GtkNotebook docs */
gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), args->active_page);
update_values(&controls);
noise_synth_invalidate(&controls);
finished = FALSE;
while (!finished) {
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
case GTK_RESPONSE_OK:
gtk_widget_destroy(dialog);
case GTK_RESPONSE_NONE:
finished = TRUE;
break;
case RESPONSE_RESET:
{
gboolean temp = args->update;
gint temp2 = args->active_page;
*args = noise_synth_defaults;
args->active_page = temp2;
args->update = temp;
}
controls.in_init = TRUE;
update_controls(&controls, args);
controls.in_init = FALSE;
if (args->update)
preview(&controls);
break;
default:
g_assert_not_reached();
break;
}
}
if (controls.sid) {
g_source_remove(controls.sid);
controls.sid = 0;
}
g_object_unref(controls.mydata);
gwy_object_unref(controls.surface);
gwy_object_unref(controls.noise);
gwy_dimensions_free(controls.dims);
return response == GTK_RESPONSE_OK;
}
static gboolean
sphrev_dialog(Sphrev1DArgs *args)
{
const GwyEnum directions[] = {
{ N_("_Horizontal direction"), SPHREV_HORIZONTAL, },
{ N_("_Vertical direction"), SPHREV_VERTICAL, },
{ N_("_Both directions"), SPHREV_BOTH, },
};
enum { RESPONSE_RESET = 1 };
GtkWidget *dialog, *table, *spin;
Sphrev1DControls controls;
gint response, row;
gdouble q;
dialog = gtk_dialog_new_with_buttons(_("Revolve Arc"), NULL, 0,
_("_Reset"), RESPONSE_RESET,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
table = gtk_table_new(5, 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(GTK_DIALOG(dialog)->vbox), table,
FALSE, FALSE, 4);
row = 0;
controls.in_update = TRUE;
q = args->pixelsize/args->valform->magnitude;
gwy_debug("q = %f", q);
controls.radius = gtk_adjustment_new(q*args->size, q, 16384*q, q, 10*q, 0);
spin = gwy_table_attach_hscale(table, row, _("Real _radius:"),
args->valform->units, controls.radius,
GWY_HSCALE_SQRT);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), args->valform->precision);
g_object_set_data(G_OBJECT(controls.radius), "controls", &controls);
g_signal_connect(controls.radius, "value-changed",
G_CALLBACK(radius_changed_cb), args);
row++;
controls.size = gtk_adjustment_new(args->size, 1, 16384, 1, 10, 0);
gwy_table_attach_hscale(table, row, _("_Pixel radius:"), "px",
controls.size, GWY_HSCALE_SQRT);
g_object_set_data(G_OBJECT(controls.size), "controls", &controls);
g_signal_connect(controls.size, "value-changed",
G_CALLBACK(size_changed_cb), args);
row++;
controls.direction
= gwy_radio_buttons_create(directions, G_N_ELEMENTS(directions),
G_CALLBACK(direction_changed_cb), args,
args->direction);
row = gwy_radio_buttons_attach_to_table(controls.direction,
GTK_TABLE(table), 4, row);
row += 3;
controls.do_extract
= gtk_check_button_new_with_mnemonic(_("E_xtract background"));
gtk_table_attach(GTK_TABLE(table), controls.do_extract,
0, 4, row, row+1, GTK_FILL, 0, 0, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.do_extract),
args->do_extract);
g_signal_connect(controls.do_extract, "toggled",
G_CALLBACK(do_extract_changed_cb), args);
row++;
controls.in_update = FALSE;
gtk_widget_show_all(dialog);
do {
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
gtk_widget_destroy(dialog);
case GTK_RESPONSE_NONE:
return FALSE;
break;
case GTK_RESPONSE_OK:
break;
case RESPONSE_RESET:
args->size = sphrev_defaults.size;
args->direction = sphrev_defaults.direction;
args->do_extract = sphrev_defaults.do_extract;
sphrev_dialog_update(&controls, args);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
gtk_widget_destroy(dialog);
return TRUE;
}
static gboolean
poly_level_dialog(PolyLevelArgs *args,
GwyContainer *data,
GwyDataField *dfield,
GwyDataField *mfield,
gint id)
{
enum { RESPONSE_RESET = 1 };
static const GwyEnum types[] = {
{ N_("Independent degrees"), TRUE, },
{ N_("Limited total degree"), FALSE, },
};
GtkWidget *dialog, *table, *label, *hbox;
GwyPixmapLayer *layer;
PolyLevelControls controls;
gint response;
gint row;
controls.args = args;
controls.in_update = TRUE;
controls.data = create_preview_data(data, dfield, mfield, id);
dialog = gtk_dialog_new_with_buttons(_("Remove Polynomial Background"),
NULL, 0,
_("_Reset"), RESPONSE_RESET,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
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, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox,
FALSE, FALSE, 0);
table = gtk_table_new(2, 2, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 12);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_box_pack_start(GTK_BOX(hbox), table, FALSE, FALSE, 0);
row = 0;
controls.leveled_view = gwy_data_view_new(controls.data);
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_data_prefix(GWY_DATA_VIEW(controls.leveled_view),
"/0/data");
gwy_data_view_set_base_layer(GWY_DATA_VIEW(controls.leveled_view), layer);
gtk_table_attach(GTK_TABLE(table), controls.leveled_view,
0, 1, row, row+1, 0, 0, 0, 0);
controls.bg_view = gwy_data_view_new(controls.data);
layer = gwy_layer_basic_new();
gwy_pixmap_layer_set_data_key(layer, "/1/data");
gwy_layer_basic_set_gradient_key(GWY_LAYER_BASIC(layer), "/1/base/palette");
gwy_data_view_set_data_prefix(GWY_DATA_VIEW(controls.bg_view), "/1/data");
gwy_data_view_set_base_layer(GWY_DATA_VIEW(controls.bg_view), layer);
gtk_table_attach(GTK_TABLE(table), controls.bg_view,
1, 2, row, row+1, 0, 0, 0, 0);
g_object_unref(controls.data);
row++;
label = gtk_label_new(_("Leveled data"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, row, row+1,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
label = gtk_label_new(_("Background"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 1, 2, row, row+1,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
row++;
table = gtk_table_new(7 + (mfield ? 4 : 0), 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(GTK_DIALOG(dialog)->vbox), table, TRUE, TRUE, 0);
row = 0;
controls.type_group
= gwy_radio_buttons_create(types, G_N_ELEMENTS(types),
G_CALLBACK(poly_level_type_changed),
&controls,
args->independent);
gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(controls.type_group->data),
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
controls.col_degree = gtk_adjustment_new(args->col_degree,
0, MAX_DEGREE, 1, 1, 0);
gwy_table_attach_hscale(table, row++,
_("_Horizontal polynom degree:"), NULL,
controls.col_degree, 0);
g_signal_connect(controls.col_degree, "value-changed",
G_CALLBACK(poly_level_degree_changed), &controls);
controls.row_degree = gtk_adjustment_new(args->row_degree,
0, MAX_DEGREE, 1, 1, 0);
gwy_table_attach_hscale(table, row++,
_("_Vertical polynom degree:"), NULL,
controls.row_degree, 0);
g_signal_connect(controls.row_degree, "value-changed",
G_CALLBACK(poly_level_degree_changed), &controls);
controls.same_degree
= gtk_check_button_new_with_mnemonic(_("_Same degrees"));
gtk_table_attach(GTK_TABLE(table), controls.same_degree,
0, 4, row, row+1, GTK_FILL, 0, 0, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.same_degree),
args->same_degree);
g_signal_connect(controls.same_degree, "toggled",
G_CALLBACK(poly_level_same_degree_changed), &controls);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
gtk_table_attach(GTK_TABLE(table),
GTK_WIDGET(controls.type_group->next->data),
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
controls.max_degree = gtk_adjustment_new(args->max_degree,
0, MAX_DEGREE, 1, 1, 0);
gwy_table_attach_hscale(table, row,
_("_Maximum polynom degree:"), NULL,
controls.max_degree, 0);
g_signal_connect(controls.max_degree, "value-changed",
G_CALLBACK(poly_level_max_degree_changed), &controls);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
controls.do_extract
= gtk_check_button_new_with_mnemonic(_("E_xtract background"));
gtk_table_attach(GTK_TABLE(table), controls.do_extract,
0, 4, row, row+1, GTK_FILL, 0, 0, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.do_extract),
args->do_extract);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
if (mfield) {
label = gwy_label_new_header(_("Masking Mode"));
gtk_table_attach(GTK_TABLE(table), label,
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
controls.masking_group
= gwy_radio_buttons_create(gwy_masking_type_get_enum(), -1,
G_CALLBACK(poly_level_masking_changed),
&controls, args->masking);
row = gwy_radio_buttons_attach_to_table(controls.masking_group,
GTK_TABLE(table), 3, row);
}
else
controls.masking_group = NULL;
controls.in_update = FALSE;
gtk_widget_set_sensitive(controls.same_degree, args->independent);
gwy_table_hscale_set_sensitive(controls.row_degree, args->independent);
gwy_table_hscale_set_sensitive(controls.col_degree, args->independent);
gwy_table_hscale_set_sensitive(controls.max_degree, !args->independent);
poly_level_update_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:
poly_level_update_values(&controls, args);
gtk_widget_destroy(dialog);
case GTK_RESPONSE_NONE:
return FALSE;
break;
case GTK_RESPONSE_OK:
break;
case RESPONSE_RESET:
*args = poly_level_defaults;
poly_level_dialog_update(&controls, args);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
poly_level_update_values(&controls, args);
gtk_widget_destroy(dialog);
return TRUE;
}
static gboolean
level_dialog(LevelArgs *args,
const gchar *title)
{
enum { RESPONSE_RESET = 1 };
static const GwyEnum modes[] = {
{ N_("_Exclude region under mask"), LEVEL_EXCLUDE, },
{ N_("Exclude region _outside mask"), LEVEL_INCLUDE, },
{ N_("Use entire _image (ignore mask)"), LEVEL_NORMAL, },
};
GtkWidget *dialog, *label, *table;
gint row, response;
LevelControls controls;
controls.args = args;
dialog = gtk_dialog_new_with_buttons(title, NULL, 0,
_("_Reset"), RESPONSE_RESET,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
table = gtk_table_new(12, 3, 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_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), table);
row = 0;
label = gwy_label_new_header(_("Plane Fit Mode"));
gtk_table_attach(GTK_TABLE(table), label,
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
controls.mode = gwy_radio_buttons_create(modes, G_N_ELEMENTS(modes),
G_CALLBACK(mode_changed_cb),
&controls, args->level_mode);
row = gwy_radio_buttons_attach_to_table(controls.mode, GTK_TABLE(table),
3, row);
gtk_widget_show_all(dialog);
do {
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
gtk_widget_destroy(dialog);
case GTK_RESPONSE_NONE:
return FALSE;
break;
case GTK_RESPONSE_OK:
break;
case RESPONSE_RESET:
*args = level_defaults;
gwy_radio_buttons_set_current(controls.mode, args->level_mode);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
gtk_widget_destroy(dialog);
return TRUE;
}
static gboolean
curvature_dialog(CurvatureArgs *args,
GwyContainer *data,
GwyDataField *dfield,
GwyDataField *mfield,
gint id)
{
enum { RESPONSE_RESET = 1 };
GtkWidget *dialog, *table, *label, *hbox, *vbox, *treeview, *button, *hbox2;
GwyDataChooser *chooser;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GwyPixmapLayer *player;
GwyVectorLayer *vlayer;
CurvatureControls controls;
gint response;
gint row;
controls.args = args;
controls.unit = gwy_data_field_get_si_unit_xy(dfield);
gwy_clear(controls.params, PARAM_NPARAMS);
controls.gmodel = gwy_graph_model_new();
init_graph_model_units(controls.gmodel, dfield);
dialog = gtk_dialog_new_with_buttons(_("Curvature"),
NULL, 0,
_("_Reset"), RESPONSE_RESET,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
gwy_help_add_to_proc_dialog(GTK_DIALOG(dialog), GWY_HELP_DEFAULT);
controls.dialog = dialog;
hbox = gtk_hbox_new(FALSE, 8);
gtk_container_set_border_width(GTK_CONTAINER(hbox), 4);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox,
FALSE, FALSE, 0);
vbox = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);
controls.data = gwy_container_new();
gwy_container_set_object_by_name(controls.data, "/0/data", dfield);
if (mfield)
gwy_container_set_object_by_name(controls.data, "/0/mask", mfield);
gwy_app_sync_data_items(data, controls.data, id, 0, FALSE,
GWY_DATA_ITEM_PALETTE,
GWY_DATA_ITEM_MASK_COLOR,
GWY_DATA_ITEM_RANGE,
GWY_DATA_ITEM_REAL_SQUARE,
0);
controls.view = gwy_data_view_new(controls.data);
player = gwy_layer_basic_new();
g_object_set(player,
"data-key", "/0/data",
"gradient-key", "/0/base/palette",
"range-type-key", "/0/base/range-type",
"min-max-key", "/0/base",
NULL);
gwy_data_view_set_data_prefix(GWY_DATA_VIEW(controls.view), "/0/data");
gwy_data_view_set_base_layer(GWY_DATA_VIEW(controls.view), player);
gwy_set_data_preview_size(GWY_DATA_VIEW(controls.view), PREVIEW_SIZE);
vlayer = g_object_new(g_type_from_name("GwyLayerLine"), NULL);
gwy_vector_layer_set_selection_key(vlayer, "/0/select/line");
gwy_vector_layer_set_editable(vlayer, FALSE);
gwy_data_view_set_top_layer(GWY_DATA_VIEW(controls.view),
GWY_VECTOR_LAYER(vlayer));
controls.selection = gwy_vector_layer_ensure_selection(vlayer);
g_object_set(controls.selection, "max-objects", 2, NULL);
gtk_box_pack_start(GTK_BOX(vbox), controls.view, FALSE, FALSE, 4);
table = gtk_table_new(5 + (mfield ? 4 : 0), 4, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 6);
gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
row = 0;
label = gwy_label_new_header(_("Output Type"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
controls.set_selection
= gtk_check_button_new_with_mnemonic(_("_Set selection"));
gtk_table_attach(GTK_TABLE(table), controls.set_selection,
0, 4, row, row+1, GTK_FILL, 0, 0, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.set_selection),
args->set_selection);
g_signal_connect(controls.set_selection, "toggled",
G_CALLBACK(curvature_set_selection_changed), &controls);
row++;
controls.plot_graph
= gtk_check_button_new_with_mnemonic(_("_Plot graph"));
gtk_table_attach(GTK_TABLE(table), controls.plot_graph,
0, 4, row, row+1, GTK_FILL, 0, 0, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.plot_graph),
args->plot_graph);
g_signal_connect(controls.plot_graph, "toggled",
G_CALLBACK(curvature_plot_graph_changed), &controls);
row++;
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
controls.target_hbox = hbox2 = gtk_hbox_new(FALSE, 6);
gtk_widget_set_sensitive(controls.target_hbox, args->plot_graph);
gtk_table_attach(GTK_TABLE(table), hbox2,
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
label = gtk_label_new_with_mnemonic(_("Target _graph:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0);
controls.target_graph = gwy_data_chooser_new_graphs();
chooser = GWY_DATA_CHOOSER(controls.target_graph);
gwy_data_chooser_set_none(chooser, _("New graph"));
gwy_data_chooser_set_active(chooser, NULL, -1);
gwy_data_chooser_set_filter(chooser, filter_target_graphs, &controls, NULL);
gwy_data_chooser_set_active_id(chooser, &args->target_graph);
gwy_data_chooser_get_active_id(chooser, &args->target_graph);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), controls.target_graph);
gtk_box_pack_end(GTK_BOX(hbox2), controls.target_graph, FALSE, FALSE, 0);
g_signal_connect_swapped(controls.target_graph, "changed",
G_CALLBACK(target_graph_changed), &controls);
row++;
if (mfield) {
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
label = gwy_label_new_header(_("Masking Mode"));
gtk_table_attach(GTK_TABLE(table), label,
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
controls.masking_group
= gwy_radio_buttons_create(gwy_masking_type_get_enum(), -1,
G_CALLBACK(curvature_masking_changed),
&controls, args->masking);
row = gwy_radio_buttons_attach_to_table(controls.masking_group,
GTK_TABLE(table), 3, row);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
}
else
controls.masking_group = NULL;
controls.warning = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(controls.warning), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), controls.warning,
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
vbox = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
controls.graph = gwy_graph_new(controls.gmodel);
gtk_widget_set_size_request(controls.graph, 320, 260);
g_object_unref(controls.gmodel);
gtk_box_pack_start(GTK_BOX(vbox), controls.graph, TRUE, TRUE, 4);
controls.paramstore = gwy_null_store_new(PARAM_NPARAMS);
treeview
= gtk_tree_view_new_with_model(GTK_TREE_MODEL(controls.paramstore));
g_object_unref(controls.paramstore);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE);
gtk_box_pack_start(GTK_BOX(vbox), treeview, FALSE, FALSE, 4);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_NONE);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Parameter"), renderer,
NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer,
render_name, param_names, NULL);
gtk_tree_view_column_set_expand(column, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Symbol"), renderer,
NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer,
render_symbol, param_symbols, NULL);
gtk_tree_view_column_set_expand(column, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(renderer, "xalign", 1.0, NULL);
column = gtk_tree_view_column_new_with_attributes(_("Value"), renderer,
NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer,
render_value, &controls, NULL);
gtk_tree_view_column_set_expand(column, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
button = curvature_add_aux_button(hbox, GTK_STOCK_SAVE,
_("Save table to a file"));
g_signal_connect_swapped(button, "clicked",
G_CALLBACK(curvature_save), &controls);
button = curvature_add_aux_button(hbox, GTK_STOCK_COPY,
_("Copy table to clipboard"));
g_signal_connect_swapped(button, "clicked",
G_CALLBACK(curvature_copy), &controls);
curvature_update_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:
gtk_widget_destroy(dialog);
case GTK_RESPONSE_NONE:
return FALSE;
break;
case GTK_RESPONSE_OK:
break;
case RESPONSE_RESET:
*args = curvature_defaults;
curvature_dialog_update(&controls, args);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
gtk_widget_destroy(dialog);
return TRUE;
}
static void
grain_dist_dialog(GrainDistArgs *args,
GwyContainer *data,
GwyDataField *dfield,
GwyDataField *mfield)
{
static const GwyEnum quantities_area[] = {
{ N_("_Projected area"), GWY_GRAIN_VALUE_PROJECTED_AREA, },
{ N_("Equivalent _square side"), GWY_GRAIN_VALUE_EQUIV_SQUARE_SIDE, },
{ N_("Equivalent disc _radius"), GWY_GRAIN_VALUE_EQUIV_DISC_RADIUS, },
{ N_("S_urface area"), GWY_GRAIN_VALUE_SURFACE_AREA, },
};
static const GwyEnum quantities_value[] = {
{ N_("Ma_ximum"), GWY_GRAIN_VALUE_MAXIMUM, },
{ N_("M_inimum"), GWY_GRAIN_VALUE_MINIMUM, },
{ N_("_Mean"), GWY_GRAIN_VALUE_MEAN, },
{ N_("Me_dian"), GWY_GRAIN_VALUE_MEDIAN, },
};
static const GwyEnum quantities_boundary[] = {
{ N_("Projected _boundary length"),
GWY_GRAIN_VALUE_FLAT_BOUNDARY_LENGTH, },
{ N_("Minimum bounding size"),
GWY_GRAIN_VALUE_MINIMUM_BOUND_SIZE, },
{ N_("Minimum bounding direction"),
GWY_GRAIN_VALUE_MINIMUM_BOUND_ANGLE, },
{ N_("Maximum bounding size"),
GWY_GRAIN_VALUE_MAXIMUM_BOUND_SIZE, },
{ N_("Maximum bounding direction"),
GWY_GRAIN_VALUE_MAXIMUM_BOUND_ANGLE, },
};
static const GwyEnum quantities_volume[] = {
{ N_("_Zero basis"), GWY_GRAIN_VALUE_VOLUME_0, },
{ N_("_Grain minimum basis"), GWY_GRAIN_VALUE_VOLUME_MIN, },
{ N_("_Laplacian background basis"), GWY_GRAIN_VALUE_VOLUME_LAPLACE, },
};
static const GwyEnum modes[] = {
{ N_("_Export raw data"), MODE_RAW, },
{ N_("Plot _graphs"), MODE_GRAPH, },
};
GrainDistControls controls;
GtkWidget *dialog;
GtkTable *table;
gint row, response;
GSList *l;
controls.args = args;
dialog = gtk_dialog_new_with_buttons(_("Grain Distributions"), NULL, 0,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
NULL);
controls.ok = 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);
/* Output type */
table = GTK_TABLE(gtk_table_new(2, 2, FALSE));
gtk_table_set_row_spacings(table, 8);
gtk_table_set_col_spacings(table, 12);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), GTK_WIDGET(table),
FALSE, FALSE, 0);
controls.qlist = append_checkbox_list(table, 0, 0, _("Value"),
NULL,
G_N_ELEMENTS(quantities_value),
quantities_value,
args->selected,
args->bitmask);
controls.qlist = append_checkbox_list(table, 1, 0, _("Area"),
controls.qlist,
G_N_ELEMENTS(quantities_area),
quantities_area,
args->selected,
args->bitmask);
controls.qlist = append_checkbox_list(table, 0, 1, _("Boundary"),
controls.qlist,
G_N_ELEMENTS(quantities_boundary),
quantities_boundary,
args->selected,
args->bitmask);
controls.qlist = append_checkbox_list(table, 1, 1, _("Volume"),
controls.qlist,
G_N_ELEMENTS(quantities_volume),
quantities_volume,
args->selected,
args->bitmask);
for (l = controls.qlist; l; l = g_slist_next(l))
g_signal_connect_swapped(l->data, "toggled",
G_CALLBACK(selected_changed_cb), &controls);
/* Options */
table = GTK_TABLE(gtk_table_new(4, 4, FALSE));
gtk_table_set_row_spacings(table, 2);
gtk_table_set_col_spacings(table, 6);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), GTK_WIDGET(table),
FALSE, FALSE, 0);
row = 0;
controls.mode = gwy_radio_buttons_create(modes, G_N_ELEMENTS(modes),
G_CALLBACK(mode_changed_cb),
&controls,
args->mode);
gtk_table_attach(table, gwy_label_new_header(_("Options")),
0, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
row = gwy_radio_buttons_attach_to_table(controls.mode, table, 4, row);
controls.resolution = gtk_adjustment_new(args->resolution,
MIN_RESOLUTION, MAX_RESOLUTION,
1, 10, 0);
gwy_table_attach_hscale(GTK_WIDGET(table), row, _("_Fix res.:"), NULL,
controls.resolution, GWY_HSCALE_CHECK);
controls.fixres = gwy_table_hscale_get_check(controls.resolution);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.fixres),
args->fixres);
gtk_widget_show_all(dialog);
grain_dist_dialog_update_sensitivity(&controls, args);
do {
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
grain_dist_dialog_update_values(&controls, args);
gtk_widget_destroy(dialog);
case GTK_RESPONSE_NONE:
return;
break;
case GTK_RESPONSE_OK:
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
grain_dist_dialog_update_values(&controls, args);
gtk_widget_destroy(dialog);
grain_dist_run(args, data, dfield, mfield);
}
static gboolean
level_grains_dialog(LevelGrainsArgs *args)
{
GtkWidget *dialog, *table, *label;
LevelGrainsControls controls;
gint response, row;
controls.args = args;
dialog = gtk_dialog_new_with_buttons(_("Level Grains"),
NULL, 0,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
gwy_help_add_to_proc_dialog(GTK_DIALOG(dialog), GWY_HELP_DEFAULT);
table = gtk_table_new(2 + G_N_ELEMENTS(level_grains_bases), 1, 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(GTK_DIALOG(dialog)->vbox), table, TRUE, TRUE, 4);
row = 0;
label = gtk_label_new(_("Quantity to level:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 1, row, row+1, GTK_FILL, 0, 0, 0);
row++;
controls.base = construct_bases_radio(args->base,
G_CALLBACK(base_changed), &controls);
row = gwy_radio_buttons_attach_to_table(controls.base, GTK_TABLE(table),
1, row);
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
controls.do_extract
= gtk_check_button_new_with_mnemonic(_("E_xtract background"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.do_extract),
args->do_extract);
gtk_table_attach(GTK_TABLE(table), controls.do_extract,
0, 1, row, row+1, GTK_FILL, 0, 0, 0);
g_signal_connect_swapped(controls.do_extract, "toggled",
G_CALLBACK(do_extract_changed), &controls);
row++;
gtk_widget_show_all(dialog);
do {
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
gtk_widget_destroy(dialog);
case GTK_RESPONSE_NONE:
return FALSE;
break;
case GTK_RESPONSE_OK:
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
gtk_widget_destroy(dialog);
return TRUE;
}
