static GSList*
append_checkbox_list(GtkTable *table,
gint row,
gint col,
const gchar *title,
GSList *list,
guint nchoices,
const GwyEnum *choices,
guint state,
guint bitmask)
{
GtkWidget *label, *check;
GtkBox *vbox;
guint i, bit;
vbox = GTK_BOX(gtk_vbox_new(FALSE, 2));
gtk_table_attach(table, GTK_WIDGET(vbox),
col, col + 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
label = gwy_label_new_header(title);
gtk_box_pack_start(vbox, label, FALSE, FALSE, 0);
for (i = 0; i < nchoices; i++) {
bit = 1 << choices[i].value;
if (!(bit & bitmask))
continue;
check = gtk_check_button_new_with_mnemonic(_(choices[i].name));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), state & bit);
g_object_set_data(G_OBJECT(check), "bit", GUINT_TO_POINTER(bit));
gtk_box_pack_start(vbox, check, FALSE, FALSE, 0);
list = g_slist_prepend(list, check);
}
return list;
}
static void
facets_dialog(FacetsArgs *args,
GwyContainer *data,
GwyContainer *fdata,
GwyDataField *dfield,
GwyDataField *mfield,
gint id,
GQuark mquark)
{
GtkWidget *dialog, *table, *hbox, *hbox2, *vbox, *label, *scale, *button;
GtkWidget *spin;
FacetsControls controls;
enum {
RESPONSE_RESET = 1,
RESPONSE_PREVIEW = 2
};
gint response;
GwyPixmapLayer *layer;
GwyVectorLayer *vlayer;
GwySelection *selection;
gint row;
memset(&controls, 0, sizeof(FacetsControls));
controls.args = args;
dialog = gtk_dialog_new_with_buttons(_("Mark Facets"),
NULL,
GTK_DIALOG_DESTROY_WITH_PARENT,
_("_Mark"), RESPONSE_PREVIEW,
_("_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);
controls.dialog = dialog;
/* Shallow-copy stuff to temporary container */
controls.fdata = fdata;
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_RANGE,
GWY_DATA_ITEM_MASK_COLOR,
GWY_DATA_ITEM_REAL_SQUARE,
0);
hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox,
FALSE, FALSE, 4);
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",
"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), layer);
gwy_set_data_preview_size(GWY_DATA_VIEW(controls.view), PREVIEW_SIZE);
vlayer = g_object_new(g_type_from_name("GwyLayerPoint"), NULL);
gwy_vector_layer_set_selection_key(vlayer, "/0/select/pointer");
gwy_data_view_set_top_layer(GWY_DATA_VIEW(controls.view), vlayer);
selection = gwy_vector_layer_ensure_selection(vlayer);
g_signal_connect(selection, "changed",
G_CALLBACK(preview_selection_updated), &controls);
gtk_box_pack_start(GTK_BOX(hbox), controls.view, FALSE, FALSE, 4);
vbox = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
hbox2 = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, 0);
/* Slope view */
controls.fview = gwy_data_view_new(controls.fdata);
gtk_box_pack_start(GTK_BOX(hbox2), controls.fview, FALSE, FALSE, 0);
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.fview),
layer);
vlayer = g_object_new(g_type_from_name("GwyLayerPoint"), NULL);
gwy_vector_layer_set_selection_key(vlayer, "/0/select/pointer");
gwy_data_view_set_top_layer(GWY_DATA_VIEW(controls.fview),
GWY_VECTOR_LAYER(vlayer));
selection = gwy_vector_layer_ensure_selection(vlayer);
g_signal_connect(selection, "changed",
G_CALLBACK(facet_view_selection_updated), &controls);
/* Info table */
table = gtk_table_new(7, 2, 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(hbox2), table, TRUE, TRUE, 4);
row = 0;
label = gwy_label_new_header(gwy_sgettext("noun|Normal"));
gtk_table_attach(GTK_TABLE(table), label,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
row++;
controls.theta_label = add_angle_label(table, _("θ:"), &row);
controls.phi_label = add_angle_label(table, _("φ:"), &row);
button = gtk_button_new_with_mnemonic(_("_Find Maximum"));
gtk_table_attach(GTK_TABLE(table), button,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
g_signal_connect_swapped(button, "clicked",
G_CALLBACK(facet_view_reset_maximum), &controls);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
label = gwy_label_new_header(_("Mean Normal"));
gtk_table_attach(GTK_TABLE(table), label,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
row++;
controls.mtheta_label = add_angle_label(table, _("θ:"), &row);
controls.mphi_label = add_angle_label(table, _("φ:"), &row);
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
label = gtk_label_new_with_mnemonic(_("Facet plane size:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
row++;
controls.kernel_size = gtk_adjustment_new(args->kernel_size,
0.0, MAX_PLANE_SIZE, 1.0, 1.0, 0);
spin = gtk_spin_button_new(GTK_ADJUSTMENT(controls.kernel_size), 0.0, 0);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), spin);
gtk_table_attach(GTK_TABLE(table), spin,
0, 1, row, row+1, 0, 0, 0, 0);
g_signal_connect(controls.kernel_size, "value-changed",
G_CALLBACK(facet_view_recompute), &controls);
row++;
table = gtk_table_new(9, 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(vbox), table, TRUE, TRUE, 4);
row = 0;
controls.tolerance = gtk_adjustment_new(args->tolerance*180.0/G_PI,
0.0, 15.0, 0.01, 0.1, 0);
scale = gwy_table_attach_hscale(table, row++, _("_Tolerance:"), _("deg"),
controls.tolerance, 0);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(scale), 3);
g_signal_connect(controls.tolerance, "value-changed",
G_CALLBACK(facets_tolerance_changed), &controls);
controls.color_button = gwy_color_button_new();
gwy_color_button_set_use_alpha(GWY_COLOR_BUTTON(controls.color_button),
TRUE);
load_mask_color(controls.color_button,
gwy_data_view_get_data(GWY_DATA_VIEW(controls.view)));
gwy_table_attach_hscale(table, row++, _("_Mask color:"), NULL,
GTK_OBJECT(controls.color_button),
GWY_HSCALE_WIDGET_NO_EXPAND);
g_signal_connect(controls.color_button, "clicked",
G_CALLBACK(mask_color_change_cb), &controls);
if (!gwy_si_unit_equal(gwy_data_field_get_si_unit_xy(dfield),
gwy_data_field_get_si_unit_z(dfield))) {
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
label = gtk_label_new(_("Warning: Lateral and value units differ. "
"Angles are not physically meaningful."));
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
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++;
}
facets_invalidate(&controls);
gtk_widget_show_all(dialog);
facet_view_select_angle(&controls, args->theta0, args->phi0);
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:
g_object_unref(controls.mydata);
return;
break;
case GTK_RESPONSE_OK:
break;
case RESPONSE_RESET:
args->tolerance = facets_defaults.tolerance;
args->kernel_size = facets_defaults.kernel_size;
facets_dialog_update_controls(&controls, args);
break;
case RESPONSE_PREVIEW:
preview(&controls, args);
update_average_angle(&controls, args);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
gwy_app_sync_data_items(controls.mydata, data, 0, id, FALSE,
GWY_DATA_ITEM_MASK_COLOR,
0);
gtk_widget_destroy(dialog);
if (controls.computed) {
mfield = gwy_container_get_object_by_name(controls.mydata, "/0/mask");
gwy_app_undo_qcheckpointv(data, 1, &mquark);
gwy_container_set_object(data, mquark, mfield);
g_object_unref(controls.mydata);
}
else {
g_object_unref(controls.mydata);
run_noninteractive(args, data, fdata, dfield, mfield, mquark);
}
}
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 void
deposit_dialog(DepositArgs *args,
GwyContainer *data,
GwyDataField *dfield,
gint id)
{
GtkWidget *dialog, *table, *hbox, *label, *pivot;
DepositControls controls;
gint response;
GwyPixmapLayer *layer;
gint row, newid;
GwyDataField *rfield;
controls.args = args;
dialog = gtk_dialog_new_with_buttons(_("Deposit spherical particles"), NULL, 0,
NULL);
gtk_dialog_add_action_widget(GTK_DIALOG(dialog),
gwy_stock_like_button_new(_("_Start"),
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);
controls.dialog = dialog;
hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox,
FALSE, FALSE, 4);
controls.mydata = gwy_container_duplicate_by_prefix(data,
"/0/data/",
"/0/base/palette",
"/0/base/range-type",
"/0/base/", NULL);
gwy_container_set_object_by_name(controls.mydata, "/0/data", gwy_data_field_duplicate(dfield));
controls.old_dfield = gwy_data_field_duplicate(dfield);
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",
"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), layer);
gwy_set_data_preview_size(GWY_DATA_VIEW(controls.view), PREVIEW_SIZE);
gtk_box_pack_start(GTK_BOX(hbox), controls.view, FALSE, FALSE, 4);
table = gtk_table_new(10, 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, TRUE, TRUE, 4);
row = 0;
gtk_table_attach(GTK_TABLE(table), gwy_label_new_header(_("Deposition parameters:")),
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
table_attach_threshold(table, &row, _("_Size"),
&controls.size, args->size,
&controls);
pivot = gwy_table_hscale_get_scale(controls.size);
controls.value_size = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(controls.value_size), 1.0, 0.5);
gtk_table_attach(GTK_TABLE(table), controls.value_size,
2, 3, row, row+1, GTK_FILL, 0, 0, 0);
g_signal_connect_swapped(controls.size, "value-changed",
G_CALLBACK(update_threshold_size), &controls);
gwy_widget_sync_sensitivity(pivot, controls.value_size);
controls.format_size
= gwy_data_field_get_value_format_z(dfield, GWY_SI_UNIT_FORMAT_VFMARKUP,
NULL);
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_label_set_markup(GTK_LABEL(label), controls.format_size->units);
gtk_table_attach(GTK_TABLE(table), label,
3, 4, row, row+1, GTK_FILL, 0, 0, 0);
gwy_widget_sync_sensitivity(pivot, label);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
/*
table_attach_threshold(table, &row, _("_Distribution width"),
&controls.width, args->width,
&controls);
pivot = gwy_table_hscale_get_scale(controls.width);
controls.value_width = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(controls.value_width), 1.0, 0.5);
gtk_table_attach(GTK_TABLE(table), controls.value_width,
2, 3, row, row+1, GTK_FILL, 0, 0, 0);
g_signal_connect_swapped(controls.width, "value-changed",
G_CALLBACK(update_threshold_width), &controls);
gwy_widget_sync_sensitivity(pivot, controls.value_width);
controls.format_width
= gwy_data_field_get_value_format_z(dfield, GWY_SI_UNIT_FORMAT_VFMARKUP,
NULL);
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_label_set_markup(GTK_LABEL(label), controls.format_width->units);
gtk_table_attach(GTK_TABLE(table), label,
3, 4, row, row+1, GTK_FILL, 0, 0, 0);
gwy_widget_sync_sensitivity(pivot, label);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
*/
table_attach_threshold(table, &row, _("_Coverage:"),
&controls.coverage, args->coverage,
&controls);
table_attach_threshold(table, &row, _("_Revise after settle"),
&controls.revise, args->revise,
&controls);
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
deposit_invalidate(&controls);
update_threshold_size(&controls);
//update_threshold_width(&controls);
/* finished initializing, allow instant updates */
controls.in_init = FALSE;
/* show initial preview if instant updates are on */
gtk_widget_show_all(dialog);
do {
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
deposit_dialog_update_values(&controls, args);
gtk_widget_destroy(dialog);
case GTK_RESPONSE_NONE:
g_object_unref(controls.mydata);
gwy_si_unit_value_format_free(controls.format_size);
//gwy_si_unit_value_format_free(controls.format_width);
return;
break;
case GTK_RESPONSE_OK:
break;
case RESPONSE_RESET:
*args = deposit_defaults;
deposit_dialog_update_controls(&controls, args);
controls.in_init = TRUE;
preview(&controls, args);
controls.in_init = FALSE;
break;
case RESPONSE_PREVIEW:
deposit_dialog_update_values(&controls, args);
preview(&controls, args);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
deposit_dialog_update_values(&controls, args);
gwy_app_sync_data_items(controls.mydata, data, 0, id, FALSE,
GWY_DATA_ITEM_MASK_COLOR,
0);
gtk_widget_destroy(dialog);
gwy_si_unit_value_format_free(controls.format_size);
//gwy_si_unit_value_format_free(controls.format_width);
if (args->computed) {
rfield = gwy_container_get_object_by_name(controls.mydata, "/0/data");
newid = gwy_app_data_browser_add_data_field(rfield,
data, TRUE);
gwy_app_sync_data_items(data, data,
id, newid, FALSE,
GWY_DATA_ITEM_GRADIENT,
GWY_DATA_ITEM_MASK_COLOR,
GWY_DATA_ITEM_REAL_SQUARE,
GWY_DATA_ITEM_SELECTIONS,
0);
gwy_app_set_data_field_title(data, newid, _("Particles"));
g_object_unref(controls.mydata);
}
}
static void
tip_blind_dialog(TipBlindArgs *args)
{
GtkWidget *dialog, *table, *hbox, *vbox, *label;
GwyContainer *data;
GwyGraphModel *gmodel;
GwyGraphArea *area;
TipBlindControls controls;
GwyPixmapLayer *layer;
GwyDataField *dfield;
GQuark quark;
GwySIUnit *unit;
gint response, row;
dialog = gtk_dialog_new_with_buttons(_("Blind Tip Estimation"), NULL, 0,
_("Run _Partial"), RESPONSE_ESTIMATE,
_("Run _Full"), RESPONSE_REFINE,
_("_Reset Tip"), 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.args = args;
controls.in_update = TRUE;
controls.good_tip = FALSE;
controls.dialog = dialog;
gtk_dialog_set_response_sensitive(GTK_DIALOG(dialog), GTK_RESPONSE_OK,
controls.good_tip);
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox,
FALSE, FALSE, 4);
controls.vxres = 240;
controls.vyres = 240;
controls.oldnstripes = args->nstripes;
/* set initial tip properties */
data = gwy_app_data_browser_get(args->source.datano);
quark = gwy_app_get_data_key_for_id(args->source.id);
dfield = GWY_DATA_FIELD(gwy_container_get_object(data, quark));
controls.tip = gwy_data_field_new_alike(dfield, TRUE);
gwy_data_field_resample(controls.tip, args->xres, args->yres,
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(data, controls.vtip,
args->source.id, 0, FALSE,
GWY_DATA_ITEM_PALETTE,
0);
dfield = gwy_data_field_new_alike(controls.tip, TRUE);
gwy_data_field_resample(dfield, controls.vxres, controls.vyres,
GWY_INTERPOLATION_ROUND);
gwy_container_set_object_by_name(controls.vtip, "/0/data", dfield);
g_object_unref(dfield);
/* set up rescaled image of the tip */
vbox = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 4);
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 estimation controls */
gtk_box_pack_start(GTK_BOX(vbox), controls.view, FALSE, FALSE, 0);
gmodel = gwy_graph_model_new();
controls.graph = gwy_graph_new(gmodel);
g_object_unref(gmodel);
gwy_axis_set_visible(gwy_graph_get_axis(GWY_GRAPH(controls.graph),
GTK_POS_LEFT),
FALSE);
gwy_axis_set_visible(gwy_graph_get_axis(GWY_GRAPH(controls.graph),
GTK_POS_BOTTOM),
FALSE);
area = GWY_GRAPH_AREA(gwy_graph_get_area(GWY_GRAPH(controls.graph)));
gtk_widget_set_no_show_all(gwy_graph_area_get_label(area), TRUE);
g_signal_connect_after(gwy_graph_area_get_label(area), "map",
G_CALLBACK(gtk_widget_hide), NULL);
gtk_box_pack_start(GTK_BOX(vbox), controls.graph, TRUE, TRUE, 0);
table = gtk_table_new(13, 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.data = gwy_data_chooser_new_channels();
gwy_data_chooser_set_filter(GWY_DATA_CHOOSER(controls.data),
tip_blind_source_filter, &args->orig, NULL);
gwy_data_chooser_set_active_id(GWY_DATA_CHOOSER(controls.data),
&args->source);
g_signal_connect(controls.data, "changed",
G_CALLBACK(data_changed), &args->source);
gwy_table_attach_hscale(table, row, _("Related _data:"), NULL,
GTK_OBJECT(controls.data), GWY_HSCALE_WIDGET);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
label = gtk_label_new(_("Estimated Tip Size"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 4, row, row+1, GTK_FILL, 0, 0, 0);
row++;
controls.xres = gtk_adjustment_new(args->xres, MIN_RES, MAX_RES, 1, 10, 0);
gwy_table_attach_hscale(table, row, _("_Width:"), "px", controls.xres, 0);
g_object_set_data(G_OBJECT(controls.xres), "controls", &controls);
g_signal_connect(controls.xres, "value-changed",
G_CALLBACK(width_changed), &controls);
row++;
controls.yres = gtk_adjustment_new(args->yres, MIN_RES, MAX_RES, 1, 10, 0);
gwy_table_attach_hscale(table, row, _("_Height:"), "px", controls.yres, 0);
g_object_set_data(G_OBJECT(controls.yres), "controls", &controls);
g_signal_connect(controls.yres, "value-changed",
G_CALLBACK(height_changed), &controls);
row++;
controls.same_resolution
= gtk_check_button_new_with_mnemonic(_("_Same resolution"));
gtk_table_attach(GTK_TABLE(table), controls.same_resolution,
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.same_resolution),
args->same_resolution);
g_signal_connect(controls.same_resolution, "toggled",
G_CALLBACK(same_resolution_changed), &controls);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
gtk_table_attach(GTK_TABLE(table), gwy_label_new_header(_("Options")),
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
controls.threshold = gtk_adjustment_new(1.0, 0.01, 1000.0, 0.01, 1.0, 0.0);
controls.threshold_spin
= gtk_spin_button_new(GTK_ADJUSTMENT(controls.threshold), 0.1, 2);
gtk_table_attach(GTK_TABLE(table), controls.threshold_spin,
2, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
label = gtk_label_new_with_mnemonic(_("Noise suppression t_hreshold:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), controls.threshold_spin);
gtk_table_attach(GTK_TABLE(table), label,
0, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
unit = gwy_data_field_get_si_unit_z(dfield);
controls.threshold_unit
= gwy_combo_box_metric_unit_new(G_CALLBACK(thresh_changed),
&controls,
-12, -3, unit, -9);
gtk_table_attach(GTK_TABLE(table), controls.threshold_unit,
3, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
g_signal_connect(controls.threshold, "value-changed",
G_CALLBACK(thresh_changed), &controls);
sci_entry_set_value(GTK_ADJUSTMENT(controls.threshold),
GTK_COMBO_BOX(controls.threshold_unit),
args->thresh);
row++;
controls.boundaries
= gtk_check_button_new_with_mnemonic(_("Use _boundaries"));
gtk_table_attach(GTK_TABLE(table), controls.boundaries,
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.boundaries),
args->use_boundaries);
g_signal_connect(controls.boundaries, "toggled",
G_CALLBACK(bound_changed), args);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
gtk_table_attach(GTK_TABLE(table), gwy_label_new_header(_("Stripes")),
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
controls.nstripes = gtk_adjustment_new(args->nstripes,
MIN_STRIPES, MAX_STRIPES, 1, 10, 0);
gwy_table_attach_hscale(table, row, _("_Split to stripes:"), NULL,
controls.nstripes, GWY_HSCALE_CHECK);
controls.split_to_stripes = gwy_table_hscale_get_check(controls.nstripes);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.split_to_stripes),
!args->split_to_stripes);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.split_to_stripes),
args->split_to_stripes);
g_signal_connect(controls.split_to_stripes, "toggled",
G_CALLBACK(split_to_stripes_changed), &controls);
g_signal_connect(controls.nstripes, "value-changed",
G_CALLBACK(nstripes_changed), &controls);
row++;
controls.stripeno = gtk_adjustment_new(1, 1, args->nstripes, 1, 10, 0);
gwy_table_attach_hscale(table, row, _("_Preview stripe:"), NULL,
controls.stripeno, GWY_HSCALE_DEFAULT);
g_signal_connect(controls.stripeno, "value-changed",
G_CALLBACK(stripeno_changed), &controls);
row++;
controls.plot_size_graph
= gtk_check_button_new_with_mnemonic(_("Plot size _graph"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.plot_size_graph),
args->plot_size_graph);
gtk_table_attach(GTK_TABLE(table), controls.plot_size_graph,
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
g_signal_connect(controls.plot_size_graph, "toggled",
G_CALLBACK(plot_size_graph_changed), &controls);
row++;
controls.create_images
= gtk_check_button_new_with_mnemonic(_("Create tip i_mages"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.create_images),
args->create_images);
gtk_table_attach(GTK_TABLE(table), controls.create_images,
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
g_signal_connect(controls.create_images, "toggled",
G_CALLBACK(create_images_changed), &controls);
row++;
controls.tipdone = FALSE;
controls.in_update = FALSE;
split_to_stripes_changed(GTK_TOGGLE_BUTTON(controls.split_to_stripes),
&controls);
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:
tip_blind_dialog_abandon(&controls);
tip_blind_save_args(gwy_app_settings_get(), args);
return;
break;
case GTK_RESPONSE_OK:
tip_blind_save_args(gwy_app_settings_get(), args);
tip_blind_do(&controls, args);
break;
case RESPONSE_RESET:
reset(&controls, args);
break;
case RESPONSE_ESTIMATE:
tip_blind_run(&controls, args, FALSE);
break;
case RESPONSE_REFINE:
tip_blind_run(&controls, args, TRUE);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
gtk_widget_destroy(dialog);
tip_blind_dialog_abandon(&controls);
return;
}
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 void
facets_dialog(FacetsArgs *args,
GwyContainer *data,
GwyContainer *fdata,
GwyDataField *dfield,
GwyDataField *mfield,
gint id,
GQuark mquark)
{
GtkWidget *dialog, *table, *hbox, *hbox2, *vbox, *label, *scale, *button;
GtkWidget *spin;
FacetsControls controls;
gint response;
GwySelection *selection;
gint row;
gwy_clear(&controls, 1);
controls.args = args;
dialog = gtk_dialog_new_with_buttons(_("Mark Facets"),
NULL,
GTK_DIALOG_DESTROY_WITH_PARENT,
gwy_sgettext("verb|_Mark"),
RESPONSE_PREVIEW,
_("_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;
/* Shallow-copy stuff to temporary container */
controls.fdata = fdata;
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_RANGE,
GWY_DATA_ITEM_MASK_COLOR,
GWY_DATA_ITEM_REAL_SQUARE,
0);
hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox,
FALSE, FALSE, 4);
controls.view = create_preview(controls.mydata, 0, PREVIEW_SIZE, TRUE);
gtk_box_pack_start(GTK_BOX(hbox), controls.view, FALSE, FALSE, 4);
selection = create_vector_layer(GWY_DATA_VIEW(controls.view), 0, "Point",
TRUE);
g_signal_connect(selection, "changed",
G_CALLBACK(preview_selection_updated), &controls);
vbox = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
hbox2 = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, 0);
/* Slope view */
controls.fview = create_preview(controls.fdata, 0, FDATA_RES, TRUE);
gtk_box_pack_start(GTK_BOX(hbox2), controls.fview, FALSE, FALSE, 0);
selection = create_vector_layer(GWY_DATA_VIEW(controls.fview), 0, "Point",
TRUE);
g_signal_connect(selection, "changed",
G_CALLBACK(facet_view_selection_updated), &controls);
/* Info table */
table = gtk_table_new(7, 2, 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(hbox2), table, TRUE, TRUE, 4);
row = 0;
/* TRANSLATORS: The direction or line orthogonal to something. */
label = gwy_label_new_header(_("Normal"));
gtk_table_attach(GTK_TABLE(table), label,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
row++;
controls.theta_label = add_angle_label(table, _("θ:"), &row);
controls.phi_label = add_angle_label(table, _("φ:"), &row);
button = gtk_button_new_with_mnemonic(_("_Find Maximum"));
gtk_table_attach(GTK_TABLE(table), button,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
g_signal_connect_swapped(button, "clicked",
G_CALLBACK(facet_view_reset_maximum), &controls);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
label = gwy_label_new_header(_("Mean Normal"));
gtk_table_attach(GTK_TABLE(table), label,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
row++;
controls.mtheta_label = add_angle_label(table, _("θ:"), &row);
controls.mphi_label = add_angle_label(table, _("φ:"), &row);
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
label = gtk_label_new_with_mnemonic(_("Facet plane size:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
row++;
controls.kernel_size = gtk_adjustment_new(args->kernel_size,
0.0, MAX_PLANE_SIZE, 1.0, 1.0, 0);
spin = gtk_spin_button_new(GTK_ADJUSTMENT(controls.kernel_size), 0.0, 0);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), spin);
gtk_table_attach(GTK_TABLE(table), spin,
0, 1, row, row+1, 0, 0, 0, 0);
g_signal_connect(controls.kernel_size, "value-changed",
G_CALLBACK(facet_view_recompute), &controls);
row++;
table = gtk_table_new(4 + 2*(!!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(vbox), table, TRUE, TRUE, 4);
row = 0;
controls.tolerance = gtk_adjustment_new(args->tolerance*180.0/G_PI,
0.0, 15.0, 0.01, 0.1, 0);
scale = gwy_table_attach_hscale(table, row++, _("_Tolerance:"), _("deg"),
controls.tolerance, 0);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(scale), 3);
g_signal_connect(controls.tolerance, "value-changed",
G_CALLBACK(facets_tolerance_changed), &controls);
if (mfield) {
gwy_container_set_object_by_name(controls.fdata, "/1/mask", mfield);
controls.combine
= gtk_check_button_new_with_mnemonic(_("Com_bine with "
"existing mask"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.combine),
args->combine);
gtk_table_attach(GTK_TABLE(table), controls.combine,
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
g_signal_connect(controls.combine, "toggled",
G_CALLBACK(combine_changed), &controls);
row++;
controls.combine_type
= gwy_enum_combo_box_new(gwy_merge_type_get_enum(), -1,
G_CALLBACK(combine_type_changed), &controls,
args->combine_type, TRUE);
gwy_table_attach_hscale(table, row, _("Operation:"), NULL,
GTK_OBJECT(controls.combine_type),
GWY_HSCALE_WIDGET);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
}
controls.color_button = create_mask_color_button(controls.mydata, dialog,
0);
gwy_table_attach_hscale(table, row, _("_Mask color:"), NULL,
GTK_OBJECT(controls.color_button),
GWY_HSCALE_WIDGET_NO_EXPAND);
row++;
if (!gwy_si_unit_equal(gwy_data_field_get_si_unit_xy(dfield),
gwy_data_field_get_si_unit_z(dfield))) {
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
label = gtk_label_new(_("Warning: Lateral and value units differ. "
"Angles are not physically meaningful."));
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
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++;
}
gtk_widget_show_all(dialog);
facet_view_select_angle(&controls, args->theta0, args->phi0);
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:
g_object_unref(controls.mydata);
facets_save_args(gwy_app_settings_get(), args);
return;
break;
case GTK_RESPONSE_OK:
break;
case RESPONSE_RESET:
args->tolerance = facets_defaults.tolerance;
args->kernel_size = facets_defaults.kernel_size;
facets_dialog_update_controls(&controls, args);
break;
case RESPONSE_PREVIEW:
preview(&controls, args);
update_average_angle(&controls, args);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
gwy_app_sync_data_items(controls.mydata, data, 0, id, FALSE,
GWY_DATA_ITEM_MASK_COLOR,
0);
gtk_widget_destroy(dialog);
g_object_unref(controls.mydata);
run_noninteractive(args, data, fdata, dfield, mfield, mquark);
facets_save_args(gwy_app_settings_get(), args);
gwy_app_channel_log_add_proc(data, id, id);
}
static void
gedge_dialog(GEdgeArgs *args,
GwyContainer *data,
GwyDataField *dfield,
gint id,
GQuark mquark)
{
GtkWidget *dialog, *table, *hbox;
GEdgeControls controls;
GwyPixmapLayer *layer;
gint row;
gint response;
gboolean temp;
controls.in_init = TRUE;
controls.args = args;
dialog = gtk_dialog_new_with_buttons(_("Mark Grains by Edge Detection"), 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_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);
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,
GWY_DATA_ITEM_REAL_SQUARE,
0);
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",
"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), layer);
gwy_set_data_preview_size(GWY_DATA_VIEW(controls.view), PREVIEW_SIZE);
gtk_box_pack_start(GTK_BOX(hbox), controls.view, FALSE, FALSE, 4);
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(hbox), table, TRUE, TRUE, 4);
row = 0;
gtk_table_attach(GTK_TABLE(table), gwy_label_new_header(_("Threshold")),
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
table_attach_threshold(table, &row, _("_Laplacian:"),
&controls.threshold_laplasian,
args->threshold_laplasian,
&controls);
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
gtk_table_attach(GTK_TABLE(table), gwy_label_new_header(_("Options")),
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
controls.color_button = gwy_color_button_new();
gwy_color_button_set_use_alpha(GWY_COLOR_BUTTON(controls.color_button),
TRUE);
load_mask_color(controls.color_button,
gwy_data_view_get_data(GWY_DATA_VIEW(controls.view)));
gwy_table_attach_hscale(table, row++, _("_Mask color:"), NULL,
GTK_OBJECT(controls.color_button),
GWY_HSCALE_WIDGET_NO_EXPAND);
g_signal_connect(controls.color_button, "clicked",
G_CALLBACK(mask_color_change_cb), &controls);
row++;
controls.update = gtk_check_button_new_with_mnemonic(_("I_nstant updates"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.update),
args->update);
gtk_table_attach(GTK_TABLE(table), controls.update,
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
g_signal_connect_swapped(controls.update, "toggled",
G_CALLBACK(update_change_cb), &controls);
gedge_invalidate(&controls);
/* finished initializing, allow instant updates */
controls.in_init = FALSE;
/* show initial preview if instant updates are on */
if (args->update) {
gtk_dialog_set_response_sensitive(GTK_DIALOG(controls.dialog),
RESPONSE_PREVIEW, FALSE);
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:
gedge_dialog_update_values(&controls, args);
gtk_widget_destroy(dialog);
case GTK_RESPONSE_NONE:
g_object_unref(controls.mydata);
gedge_save_args(gwy_app_settings_get(), args);
return;
break;
case GTK_RESPONSE_OK:
break;
case RESPONSE_RESET:
temp = args->update;
*args = gedge_defaults;
args->update = temp;
gedge_dialog_update_controls(&controls, args);
controls.in_init = TRUE;
preview(&controls, args);
controls.in_init = FALSE;
break;
case RESPONSE_PREVIEW:
gedge_dialog_update_values(&controls, args);
preview(&controls, args);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
gedge_dialog_update_values(&controls, args);
gwy_app_sync_data_items(controls.mydata, data, 0, id, FALSE,
GWY_DATA_ITEM_MASK_COLOR,
0);
gtk_widget_destroy(dialog);
gedge_save_args(gwy_app_settings_get(), args);
gwy_app_channel_log_add_proc(data, id, id);
g_object_unref(controls.mydata);
run_noninteractive(args, data, dfield, mquark);
}
static void
fit_dialog(FitArgs *args)
{
GtkWidget *label, *dialog, *hbox, *hbox2, *table, *align, *expander, *scroll;
GtkTable *table2;
GwyGraphModel *gmodel;
GwyGraphCurveModel *cmodel;
GwyGraphArea *area;
GwySelection *selection;
GwySIUnit *siunit;
FitControls controls;
gint response, row;
GString *report;
gdouble xmin, xmax;
controls.args = args;
controls.in_update = TRUE;
controls.param = g_array_new(FALSE, TRUE, sizeof(FitParamControl));
gmodel = gwy_graph_get_model(GWY_GRAPH(args->parent_graph));
gwy_graph_model_get_x_range(gmodel, &xmin, &xmax);
g_object_get(gmodel, "si-unit-x", &siunit, NULL);
args->abscissa_vf
= gwy_si_unit_get_format_with_digits(siunit,
GWY_SI_UNIT_FORMAT_VFMARKUP,
MAX(fabs(xmin), fabs(xmax)), 4,
NULL);
g_object_unref(siunit);
dialog = gtk_dialog_new_with_buttons(_("Fit FD Curve"), NULL, 0, NULL);
controls.dialog = dialog;
gtk_dialog_add_action_widget(GTK_DIALOG(dialog),
gwy_stock_like_button_new(gwy_sgettext("verb|_Fit"),
GTK_STOCK_EXECUTE),
RESPONSE_FIT);
gtk_dialog_add_button(GTK_DIALOG(dialog),
gwy_sgettext("verb|_Estimate"), RESPONSE_ESTIMATE);
gtk_dialog_add_button(GTK_DIALOG(dialog),
_("_Plot Inits"), RESPONSE_PLOT);
gtk_dialog_add_button(GTK_DIALOG(dialog),
GTK_STOCK_SAVE, RESPONSE_SAVE);
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);
gwy_help_add_to_graph_dialog(GTK_DIALOG(dialog), GWY_HELP_DEFAULT);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, TRUE, TRUE, 0);
/* Graph */
args->graph_model = gwy_graph_model_new_alike(gmodel);
controls.graph = gwy_graph_new(args->graph_model);
g_object_unref(args->graph_model);
gtk_widget_set_size_request(controls.graph, 400, 300);
gwy_graph_enable_user_input(GWY_GRAPH(controls.graph), FALSE);
gtk_box_pack_start(GTK_BOX(hbox), controls.graph, TRUE, TRUE, 0);
gwy_graph_set_status(GWY_GRAPH(controls.graph), GWY_GRAPH_STATUS_XSEL);
area = GWY_GRAPH_AREA(gwy_graph_get_area(GWY_GRAPH(controls.graph)));
selection = gwy_graph_area_get_selection(area, GWY_GRAPH_STATUS_XSEL);
gwy_selection_set_max_objects(selection, 1);
g_signal_connect(selection, "changed",
G_CALLBACK(graph_selected), &controls);
gwy_graph_model_add_curve(controls.args->graph_model,
gwy_graph_model_get_curve(gmodel, args->curve));
args->fitfunc = NULL;
/* Controls */
align = gtk_alignment_new(0.0, 0.0, 0.0, 0.0);
gtk_box_pack_start(GTK_BOX(hbox), align, FALSE, FALSE, 0);
g_signal_connect(align, "size-request", G_CALLBACK(grow_width), NULL);
table = gtk_table_new(7, 2, 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(hbox), table, FALSE, FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
row = 0;
/* Curve to fit */
label = gtk_label_new_with_mnemonic(_("_Graph curve:"));
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.curve = curve_selector_new(gmodel,
G_CALLBACK(curve_changed), &controls,
args->curve);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), controls.curve);
gtk_table_attach(GTK_TABLE(table), controls.curve,
1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
/* Fitted function */
label = gtk_label_new_with_mnemonic(_("F_unction:"));
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.function = function_selector_new(G_CALLBACK(function_changed),
&controls, args->function_type);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), controls.function);
gtk_table_attach(GTK_TABLE(table), controls.function,
1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
controls.formula = gtk_label_new("f(x) =");
gtk_misc_set_alignment(GTK_MISC(controls.formula), 0.0, 0.5);
gtk_label_set_selectable(GTK_LABEL(controls.formula), TRUE);
scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), controls.formula);
gtk_table_attach(GTK_TABLE(table), scroll,
0, 2, row, row+1, GTK_FILL, 0, 0, 8);
row++;
/* Parameters sought */
controls.param_table = gtk_table_new(1, 10, FALSE);
table2 = GTK_TABLE(controls.param_table);
gtk_table_set_row_spacing(table2, 0, 2);
gtk_table_set_col_spacings(table2, 2);
gtk_table_set_col_spacing(table2, 0, 6);
gtk_table_set_col_spacing(table2, 4, 6);
gtk_table_set_col_spacing(table2, 5, 6);
gtk_table_set_col_spacing(table2, 7, 6);
gtk_table_set_col_spacing(table2, 8, 6);
gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(table2),
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
gtk_table_attach(table2, gwy_label_new_header(_("Fix")),
0, 1, 0, 1, GTK_FILL, 0, 0, 0);
gtk_table_attach(table2, gwy_label_new_header(_("Parameter")),
1, 5, 0, 1, GTK_FILL, 0, 0, 0);
gtk_table_attach(table2, gwy_label_new_header(_("Error")),
6, 8, 0, 1, GTK_FILL, 0, 0, 0);
gtk_table_attach(table2, gwy_label_new_header(_("Initial")),
9, 10, 0, 1, GTK_FILL, 0, 0, 0);
/* Make space for 4 parameters */
#if 0
for (i = 0; i < 4; i++)
fit_param_row_create(&controls, i, table2, i+1);
#endif
/* Chi^2 */
label = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(label), _("χ<sup>2</sup> result:"));
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.chisq = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(controls.chisq), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), controls.chisq,
1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
/* Correlation matrix */
expander = gtk_expander_new(NULL);
gtk_expander_set_label_widget(GTK_EXPANDER(expander),
gwy_label_new_header(_("Correlation Matrix")));
gtk_table_attach(GTK_TABLE(table), expander,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
align = gtk_alignment_new(0.0, 0.5, 0.0, 0.0);
gtk_container_add(GTK_CONTAINER(expander), align);
row++;
controls.covar = g_array_new(FALSE, TRUE, sizeof(GtkWidget*));
controls.covar_table = gtk_table_new(1, 1, TRUE);
table2 = GTK_TABLE(controls.covar_table);
gtk_table_set_col_spacings(table2, 6);
gtk_table_set_row_spacings(table2, 2);
gtk_container_add(GTK_CONTAINER(align), GTK_WIDGET(table2));
/* Fit area */
hbox2 = gtk_hbox_new(FALSE, 6);
gtk_table_attach(GTK_TABLE(table), hbox2,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
row++;
label = gtk_label_new(_("Range:"));
gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0);
controls.from = gtk_entry_new();
g_object_set_data(G_OBJECT(controls.from), "id", (gpointer)"from");
gtk_entry_set_width_chars(GTK_ENTRY(controls.from), 8);
gtk_box_pack_start(GTK_BOX(hbox2), controls.from, FALSE, FALSE, 0);
g_signal_connect(controls.from, "activate",
G_CALLBACK(range_changed), &controls);
gwy_widget_set_activate_on_unfocus(controls.from, TRUE);
label = gtk_label_new(gwy_sgettext("range|to"));
gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0);
controls.to = gtk_entry_new();
g_object_set_data(G_OBJECT(controls.to), "id", (gpointer)"to");
gtk_entry_set_width_chars(GTK_ENTRY(controls.to), 8);
gtk_box_pack_start(GTK_BOX(hbox2), controls.to, FALSE, FALSE, 0);
g_signal_connect(controls.to, "activate",
G_CALLBACK(range_changed), &controls);
gwy_widget_set_activate_on_unfocus(controls.to, TRUE);
label = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(label), args->abscissa_vf->units);
gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0);
/* Auto-update */
hbox2 = gtk_hbox_new(FALSE, 6);
gtk_table_attach(GTK_TABLE(table), hbox2,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
row++;
label = gtk_label_new(_("Instant:"));
gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0);
controls.auto_estimate = gtk_check_button_new_with_mnemonic(_("e_stimate"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.auto_estimate),
args->auto_estimate);
gtk_box_pack_start(GTK_BOX(hbox2), controls.auto_estimate, FALSE, FALSE, 0);
g_signal_connect(controls.auto_estimate, "toggled",
G_CALLBACK(auto_estimate_changed), &controls);
controls.auto_plot = gtk_check_button_new_with_mnemonic(_("p_lot"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.auto_plot),
args->auto_plot);
gtk_box_pack_start(GTK_BOX(hbox2), controls.auto_plot, FALSE, FALSE, 0);
g_signal_connect(controls.auto_plot, "toggled",
G_CALLBACK(auto_plot_changed), &controls);
function_changed(GTK_COMBO_BOX(controls.function), &controls);
graph_selected(selection, -1, &controls);
controls.in_update = FALSE;
gtk_widget_show_all(dialog);
do {
response = gtk_dialog_run(GTK_DIALOG(dialog));
fit_fetch_entry(&controls);
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
gtk_widget_destroy(dialog);
fit_controls_free(&controls);
return;
break;
case GTK_RESPONSE_OK:
if (args->is_estimated) {
cmodel = gwy_graph_model_get_curve(args->graph_model, 1);
gwy_graph_model_add_curve(gmodel, cmodel);
}
gtk_widget_destroy(dialog);
break;
case RESPONSE_SAVE:
report = create_fit_report(args);
gwy_save_auxiliary_data(_("Save Fit Report"), GTK_WINDOW(dialog),
-1, report->str);
g_string_free(report, TRUE);
break;
case RESPONSE_ESTIMATE:
fit_estimate(&controls);
break;
case RESPONSE_PLOT:
fit_set_state(&controls, FALSE, TRUE);
fit_plot_curve(args);
break;
case RESPONSE_FIT:
fit_do(&controls);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
fit_controls_free(&controls);
}
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
unrotate_dialog(UnrotateArgs *args,
GwyContainer *data,
GwyDataField *dfield,
gint id,
gdouble *correction,
GwyPlaneSymmetry guess)
{
enum { RESPONSE_RESET = 1 };
GtkWidget *dialog, *table, *label, *hbox;
GwyPixmapLayer *layer;
UnrotateControls controls;
const gchar *s;
gint response;
gint row;
controls.correction = correction;
controls.guess = guess;
controls.args = args;
dialog = gtk_dialog_new_with_buttons(_("Correct Rotation"), 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);
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, 4);
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_box_pack_start(GTK_BOX(hbox), table, FALSE, FALSE, 0);
row = 0;
gtk_table_attach(GTK_TABLE(table), gwy_label_new_header(_("Structure")),
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
label = gtk_label_new(_("Detected:"));
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, 0, 0, 0);
s = gwy_sgettext(gwy_enum_to_string(guess, gwy_plane_symmetry_get_enum(),
-1));
label = gtk_label_new(_(s));
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, 0, 0, 0);
row++;
controls.symmetry
= gwy_enum_combo_box_new(gwy_plane_symmetry_get_enum(), -1,
G_CALLBACK(unrotate_symmetry_cb), &controls,
args->symmetry, TRUE);
gwy_table_attach_row(table, row, _("_Assume:"), NULL, controls.symmetry);
row++;
label = gtk_label_new(_("Correction:"));
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, 0, 0, 0);
controls.corrlabel = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(controls.corrlabel), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), controls.corrlabel,
1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
controls.interp
= gwy_enum_combo_box_new(gwy_interpolation_type_get_enum(), -1,
G_CALLBACK(unrotate_interp_cb), &controls,
args->interp, TRUE);
gwy_table_attach_row(table, row, _("_Interpolation type:"), "",
controls.interp);
controls.data = create_preview_data(data, dfield, id);
controls.data_view = gwy_data_view_new(controls.data);
g_object_unref(controls.data);
layer = gwy_layer_basic_new();
gwy_pixmap_layer_set_data_key(layer, "/0/show");
gwy_layer_basic_set_gradient_key(GWY_LAYER_BASIC(layer), "/0/base/palette");
gwy_data_view_set_data_prefix(GWY_DATA_VIEW(controls.data_view), "/0/data");
gwy_data_view_set_base_layer(GWY_DATA_VIEW(controls.data_view), layer);
gtk_box_pack_start(GTK_BOX(hbox), controls.data_view, FALSE, FALSE, 8);
unrotate_dialog_update(&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 = unrotate_defaults;
unrotate_dialog_update(&controls, args);
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
tilt_dialog(TiltArgs *args,
GwyDataField *dfield)
{
enum { RESPONSE_RESET = 1 };
GtkWidget *dialog, *spin, *table, *label;
GwySIUnit *unit;
gchar *unitstr;
TiltControls controls;
gboolean units_equal;
gint row, response;
unit = gwy_si_unit_new(NULL);
units_equal = gwy_si_unit_equal(gwy_data_field_get_si_unit_z(dfield),
gwy_data_field_get_si_unit_xy(dfield));
gwy_si_unit_divide(gwy_data_field_get_si_unit_z(dfield),
gwy_data_field_get_si_unit_xy(dfield),
unit);
unitstr = gwy_si_unit_get_string(unit, GWY_SI_UNIT_FORMAT_VFMARKUP);
g_object_unref(unit);
dialog = gtk_dialog_new_with_buttons(_("Tilt"), 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);
controls.args = args;
controls.in_update = TRUE;
table = gtk_table_new(5 + (units_equal ? 1 : 0), 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;
/* Slopes */
label = gwy_label_new_header(_("Slopes"));
gtk_table_attach(GTK_TABLE(table), label,
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
controls.dx = gtk_adjustment_new(args->dx, -100, 100, 1e-4, 1e-2, 0);
spin = gwy_table_attach_hscale(table, row, _("_X:"), unitstr,
controls.dx, GWY_HSCALE_NO_SCALE);
gwy_widget_set_activate_on_unfocus(spin, TRUE);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), 6);
g_signal_connect(controls.dx, "value-changed",
G_CALLBACK(tilt_dx_changed), &controls);
row++;
controls.dy = gtk_adjustment_new(args->dy, -100, 100, 1e-4, 1e-2, 0);
spin = gwy_table_attach_hscale(table, row, _("_Y:"), unitstr,
controls.dy, GWY_HSCALE_NO_SCALE);
gwy_widget_set_activate_on_unfocus(spin, TRUE);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), 6);
g_signal_connect(controls.dy, "value-changed",
G_CALLBACK(tilt_dy_changed), &controls);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
/* Angles (adjustment values will be calculated later) */
label = gwy_label_new_header(_("Angles"));
gtk_table_attach(GTK_TABLE(table), label,
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
if (units_equal) {
controls.theta = gtk_adjustment_new(0, 0, 89.6, 1e-2, 1.0, 0);
spin = gwy_table_attach_hscale(table, row, _("θ:"), _("deg"),
controls.theta, GWY_HSCALE_NO_SCALE);
gwy_widget_set_activate_on_unfocus(spin, TRUE);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), 4);
g_signal_connect_swapped(controls.theta, "value-changed",
G_CALLBACK(tilt_angle_changed), &controls);
row++;
}
else
controls.theta = gtk_adjustment_new(0, 0, 90.0, 1e-2, 1.0, 0);
controls.phi = gtk_adjustment_new(0, -180, 180, 1e-2, 1.0, 0);
spin = gwy_table_attach_hscale(table, row, _("φ:"), _("deg"),
controls.phi, GWY_HSCALE_NO_SCALE);
gwy_widget_set_activate_on_unfocus(spin, TRUE);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), 4);
g_signal_connect_swapped(controls.phi, "value-changed",
G_CALLBACK(tilt_angle_changed), &controls);
row++;
controls.in_update = FALSE;
tilt_deriv_to_angles(&controls);
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:
dialog_reset(&controls);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
gtk_widget_destroy(dialog);
return TRUE;
}