static gboolean
gwy_layer_basic_wants_repaint(GwyDataViewLayer *layer)
{
g_return_val_if_fail(GWY_IS_LAYER_BASIC(layer), FALSE);
return GWY_LAYER_BASIC(layer)->changed;
}
static void
gwy_layer_basic_plugged(GwyDataViewLayer *layer)
{
GwyLayerBasic *basic_layer;
basic_layer = GWY_LAYER_BASIC(layer);
GWY_DATA_VIEW_LAYER_CLASS(gwy_layer_basic_parent_class)->plugged(layer);
gwy_layer_basic_container_connect
(basic_layer,
g_quark_to_string(basic_layer->show_key),
&basic_layer->show_item_id,
G_CALLBACK(gwy_layer_basic_item_changed));
gwy_layer_basic_show_field_connect(basic_layer);
gwy_layer_basic_container_connect
(basic_layer,
g_quark_to_string(basic_layer->gradient_key),
&basic_layer->gradient_item_id,
G_CALLBACK(gwy_layer_basic_gradient_item_changed));
gwy_layer_basic_gradient_connect(basic_layer);
gwy_layer_basic_container_connect
(basic_layer,
g_quark_to_string(basic_layer->range_type_key),
&basic_layer->range_type_id,
G_CALLBACK(gwy_layer_basic_range_type_changed));
gwy_layer_basic_reconnect_fixed(basic_layer);
}
static void
gwy_layer_basic_update(GwyDataViewLayer *layer)
{
gwy_debug(" ");
GWY_LAYER_BASIC(layer)->changed = TRUE;
gwy_data_view_layer_updated(layer);
}
static void
gwy_layer_basic_finalize(GObject *object)
{
gwy_debug(" ");
gwy_object_unref(GWY_LAYER_BASIC(object)->gradient);
G_OBJECT_CLASS(parent_class)->finalize(object);
}
static void
gwy_layer_basic_unplugged(GwyDataViewLayer *layer)
{
GwyPixmapLayer *pixmap_layer;
GwyLayerBasic *basic_layer;
g_return_if_fail(GWY_IS_LAYER_BASIC(layer));
pixmap_layer = GWY_PIXMAP_LAYER(layer);
basic_layer = GWY_LAYER_BASIC(layer);
gwy_object_unref(pixmap_layer->pixbuf);
GWY_DATA_VIEW_LAYER_CLASS(parent_class)->unplugged(layer);
}
static void
gwy_layer_basic_destroy(GtkObject *object)
{
GwyLayerBasic *layer;
layer = GWY_LAYER_BASIC(object);
if (layer->gradient) {
gwy_resource_release(GWY_RESOURCE(layer->gradient));
layer->gradient = NULL;
}
GTK_OBJECT_CLASS(gwy_layer_basic_parent_class)->destroy(object);
}
static GdkPixbuf*
gwy_layer_basic_paint(GwyPixmapLayer *layer)
{
GwyLayerBasic *basic_layer;
GwyDataField *data_field;
GwyLayerBasicRangeType range_type;
GwyContainer *data;
gdouble min, max;
basic_layer = GWY_LAYER_BASIC(layer);
data = GWY_DATA_VIEW_LAYER(layer)->data;
data_field = GWY_DATA_FIELD(layer->data_field);
if (basic_layer->show_field)
data_field = GWY_DATA_FIELD(basic_layer->show_field);
g_return_val_if_fail(data && data_field, NULL);
/* Special-case full range, as gwy_pixbuf_draw_data_field() is simplier,
* it doesn't have to deal with outliers */
range_type = gwy_layer_basic_get_range_type(basic_layer);
gwy_pixmap_layer_make_pixbuf(layer, FALSE);
if (range_type == GWY_LAYER_BASIC_RANGE_FULL)
gwy_pixbuf_draw_data_field(layer->pixbuf, data_field,
basic_layer->gradient);
else if (range_type == GWY_LAYER_BASIC_RANGE_ADAPT)
gwy_pixbuf_draw_data_field_adaptive(layer->pixbuf, data_field,
basic_layer->gradient);
else {
if (basic_layer->show_field) {
/* Ignore fixed range in for presentations. */
if (range_type == GWY_LAYER_BASIC_RANGE_FIXED)
gwy_pixbuf_draw_data_field(layer->pixbuf, data_field,
basic_layer->gradient);
else {
gwy_data_field_get_autorange(data_field, &min, &max);
gwy_pixbuf_draw_data_field_with_range(layer->pixbuf, data_field,
basic_layer->gradient,
min, max);
}
}
else {
gwy_layer_basic_get_range(basic_layer, &min, &max);
gwy_pixbuf_draw_data_field_with_range(layer->pixbuf, data_field,
basic_layer->gradient,
min, max);
}
}
return layer->pixbuf;
}
static GdkPixbuf*
gwy_layer_basic_paint(GwyPixmapLayer *layer)
{
GwyDataField *data_field;
GwyLayerBasic *basic_layer;
GwyContainer *data;
gdouble min = 0.0, max = 0.0;
gboolean fixedmin, fixedmax;
gboolean fixedrange = FALSE;
gwy_debug(" ");
g_return_val_if_fail(GWY_IS_LAYER_BASIC(layer), NULL);
basic_layer = GWY_LAYER_BASIC(layer);
data = GWY_DATA_VIEW_LAYER(layer)->data;
/* TODO Container */
if (!gwy_container_gis_object_by_name(data, "/0/show",
(GObject**)&data_field)) {
data_field
= GWY_DATA_FIELD(gwy_container_get_object_by_name(data, "/0/data"));
fixedrange = TRUE;
}
g_return_val_if_fail(GWY_IS_DATA_FIELD(data_field), layer->pixbuf);
if (fixedrange) {
fixedmin = gwy_container_gis_double_by_name(data, "/0/base/min", &min);
fixedmax = gwy_container_gis_double_by_name(data, "/0/base/max", &max);
if (fixedmin || fixedmax) {
if (!fixedmin)
min = gwy_data_field_get_min(data_field);
if (!fixedmax)
max = gwy_data_field_get_max(data_field);
}
else
fixedrange = FALSE;
}
/* XXX */
/*if (GWY_LAYER_BASIC(layer)->changed)*/ {
if (fixedrange)
gwy_pixbuf_draw_data_field_with_range(layer->pixbuf, data_field,
basic_layer->gradient,
min, max);
else
gwy_pixbuf_draw_data_field(layer->pixbuf, data_field,
basic_layer->gradient);
basic_layer->changed = FALSE;
}
return layer->pixbuf;
}
static void
gwy_layer_basic_plugged(GwyDataViewLayer *layer)
{
GwyPixmapLayer *pixmap_layer;
GwyLayerBasic *basic_layer;
GwyDataField *data_field = NULL;
gint width, height;
const guchar *gradient_name;
gwy_debug(" ");
g_return_if_fail(GWY_IS_LAYER_BASIC(layer));
pixmap_layer = GWY_PIXMAP_LAYER(layer);
basic_layer = GWY_LAYER_BASIC(layer);
basic_layer->changed = TRUE;
GWY_DATA_VIEW_LAYER_CLASS(parent_class)->plugged(layer);
/* TODO Container */
/* XXX */
data_field = GWY_DATA_FIELD(gwy_container_get_object_by_name(layer->data,
"/0/data"));
gwy_container_gis_object_by_name(layer->data, "/0/show",
(GObject**)&data_field);
g_return_if_fail(data_field);
width = gwy_data_field_get_xres(data_field);
height = gwy_data_field_get_yres(data_field);
if (gwy_container_gis_string_by_name(layer->data, "/0/base/palette",
&gradient_name))
gwy_layer_basic_set_gradient((GwyLayerBasic*)layer, gradient_name);
else {
/* FIXME: this is probably wrong, it should work with unset gradient
* and use default, but things depend on the fact /0/base/palette
* is set. */
gwy_layer_basic_set_gradient((GwyLayerBasic*)layer,
GWY_GRADIENT_DEFAULT);
gwy_container_set_string_by_name(GWY_DATA_VIEW_LAYER(layer)->data,
"/0/base/palette",
g_strdup(GWY_GRADIENT_DEFAULT));
}
pixmap_layer->pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE,
BITS_PER_SAMPLE, width, height);
gwy_debug_objects_creation(G_OBJECT(pixmap_layer->pixbuf));
}
static void
gwy_layer_basic_unplugged(GwyDataViewLayer *layer)
{
GwyPixmapLayer *pixmap_layer;
GwyLayerBasic *basic_layer;
pixmap_layer = GWY_PIXMAP_LAYER(layer);
basic_layer = GWY_LAYER_BASIC(layer);
gwy_debug("disconnecting all handlers");
gwy_layer_basic_disconnect_fixed(basic_layer);
gwy_signal_handler_disconnect(layer->data, basic_layer->range_type_id);
gwy_signal_handler_disconnect(layer->data, basic_layer->gradient_item_id);
gwy_layer_basic_gradient_disconnect(basic_layer);
gwy_signal_handler_disconnect(layer->data, basic_layer->show_item_id);
gwy_layer_basic_show_field_disconnect(basic_layer);
gwy_object_unref(pixmap_layer->pixbuf);
GWY_DATA_VIEW_LAYER_CLASS(gwy_layer_basic_parent_class)->unplugged(layer);
}
static void
gwy_layer_basic_get_property(GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GwyLayerBasic *basic_layer = GWY_LAYER_BASIC(object);
switch (prop_id) {
case PROP_GRADIENT_KEY:
g_value_set_static_string(value,
g_quark_to_string(basic_layer->gradient_key));
break;
case PROP_PRESENTATION_KEY:
g_value_set_static_string(value,
g_quark_to_string(basic_layer->show_key));
break;
case PROP_RANGE_TYPE_KEY:
g_value_set_static_string(value,
g_quark_to_string(basic_layer->range_type_key));
break;
case PROP_DEFAULT_RANGE_TYPE:
g_value_set_enum(value,
GPOINTER_TO_UINT(basic_layer->default_range_type));
break;
case PROP_MIN_MAX_KEY:
g_value_set_static_string(value,
g_quark_to_string(basic_layer->fixed_key));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
static void
gwy_layer_basic_set_property(GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GwyLayerBasic *basic_layer = GWY_LAYER_BASIC(object);
switch (prop_id) {
case PROP_GRADIENT_KEY:
gwy_layer_basic_set_gradient_key(basic_layer,
g_value_get_string(value));
break;
case PROP_PRESENTATION_KEY:
gwy_layer_basic_set_presentation_key(basic_layer,
g_value_get_string(value));
break;
case PROP_RANGE_TYPE_KEY:
gwy_layer_basic_set_range_type_key(basic_layer,
g_value_get_string(value));
break;
case PROP_DEFAULT_RANGE_TYPE:
gwy_layer_basic_set_default_range_type(basic_layer,
g_value_get_enum(value));
break;
case PROP_MIN_MAX_KEY:
gwy_layer_basic_set_min_max_key(basic_layer,
g_value_get_string(value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
static gboolean
rotate_dialog(RotateArgs *args,
GwyContainer *data)
{
GtkWidget *dialog, *table, *hbox;
GwyPixmapLayer *layer;
RotateControls controls;
enum { RESPONSE_RESET = 1 };
gint response;
controls.args = args;
dialog = gtk_dialog_new_with_buttons(_("Rotate"), 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(3, 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, 0);
controls.angle = gtk_adjustment_new(args->angle*180.0/G_PI,
-360, 360, 0.1, 30, 0);
gwy_table_attach_hscale(table, 0, _("Rotate by _angle:"), _("deg"),
controls.angle, 0);
g_signal_connect(controls.angle, "value-changed",
G_CALLBACK(angle_changed_cb), &controls);
controls.interp
= gwy_enum_combo_box_new(gwy_interpolation_type_get_enum(), -1,
G_CALLBACK(interp_changed_cb), &controls,
args->interp, TRUE);
gwy_table_attach_hscale(table, 1, _("_Interpolation type:"), NULL,
GTK_OBJECT(controls.interp),
GWY_HSCALE_WIDGET_NO_EXPAND);
controls.expand
= gtk_check_button_new_with_mnemonic(_("E_xpand result to fit "
"complete data"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.expand),
args->expand);
gtk_table_attach(GTK_TABLE(table), controls.expand,
0, 4, 2, 3, GTK_EXPAND | GTK_FILL, 0, 0, 0);
g_signal_connect(controls.expand, "toggled",
G_CALLBACK(expand_changed_cb), &controls);
controls.data = create_preview_data(data);
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_base_layer(GWY_DATA_VIEW(controls.data_view), layer);
gtk_box_pack_start(GTK_BOX(hbox), controls.data_view, FALSE, FALSE, 8);
rotate_dialog_update(&controls, args);
rotate_preview_draw(&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 = rotate_defaults;
rotate_dialog_update(&controls, args);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
gtk_widget_destroy(dialog);
return TRUE;
}
static void
tip_model_dialog(TipModelArgs *args)
{
enum {
RESPONSE_RESET = 1,
RESPONSE_PREVIEW = 2
};
GtkWidget *dialog, *table, *hbox, *spin;
TipModelControls controls;
GwyPixmapLayer *layer;
GwyDataField *dfield;
GwySIUnit *unit;
GQuark quark;
gint response, row;
dialog = gtk_dialog_new_with_buttons(_("Model Tip"), NULL, 0, NULL);
gtk_dialog_add_action_widget(GTK_DIALOG(dialog),
gwy_stock_like_button_new(_("_Update"),
GTK_STOCK_EXECUTE),
RESPONSE_PREVIEW);
gtk_dialog_add_button(GTK_DIALOG(dialog), _("_Reset"), RESPONSE_RESET);
gtk_dialog_add_button(GTK_DIALOG(dialog),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
gtk_dialog_add_button(GTK_DIALOG(dialog),
GTK_STOCK_OK, GTK_RESPONSE_OK);
gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
hbox = gtk_hbox_new(FALSE, 3);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox,
FALSE, FALSE, 4);
controls.args = args;
controls.vxres = 200;
controls.vyres = 200;
/* set up initial tip field */
quark = gwy_app_get_data_key_for_id(args->object.id);
dfield = GWY_DATA_FIELD(gwy_container_get_object(args->object.data, quark));
controls.tip = gwy_data_field_new_alike(dfield, TRUE);
gwy_data_field_resample(controls.tip, controls.vxres, controls.vyres,
GWY_INTERPOLATION_NONE);
gwy_data_field_clear(controls.tip);
/*set up data of rescaled image of the tip*/
controls.vtip = gwy_container_new();
gwy_app_sync_data_items(args->object.data, controls.vtip,
args->object.id, 0, FALSE,
GWY_DATA_ITEM_PALETTE, 0);
dfield = gwy_data_field_new_alike(controls.tip, TRUE);
gwy_container_set_object_by_name(controls.vtip, "/0/data", dfield);
g_object_unref(dfield);
/* set up resampled view */
controls.view = gwy_data_view_new(controls.vtip);
layer = gwy_layer_basic_new();
gwy_pixmap_layer_set_data_key(layer, "/0/data");
gwy_layer_basic_set_gradient_key(GWY_LAYER_BASIC(layer), "/0/base/palette");
gwy_data_view_set_base_layer(GWY_DATA_VIEW(controls.view), layer);
/* set up tip model controls */
gtk_box_pack_start(GTK_BOX(hbox), controls.view, FALSE, FALSE, 4);
table = gtk_table_new(6, 4, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 6);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_box_pack_start(GTK_BOX(hbox), table, FALSE, FALSE, 4);
row = 0;
controls.type = create_preset_menu(G_CALLBACK(tip_type_cb),
&controls, args->type);
gwy_table_attach_hscale(table, row, _("Tip _type:"), NULL,
GTK_OBJECT(controls.type), GWY_HSCALE_WIDGET);
row++;
controls.nsides = gtk_adjustment_new(args->nsides, 3, 24, 1, 5, 0);
gwy_table_attach_hscale(table, row, _("_Number of sides:"), NULL,
controls.nsides, 0);
row++;
controls.angle = gtk_adjustment_new(args->angle, 0.1, 89.9, 0.1, 1, 0);
spin = gwy_table_attach_hscale(table, row, _("Tip _slope:"), _("deg"),
controls.angle, 0);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), 2);
row++;
controls.theta = gtk_adjustment_new(args->theta, 0, 360, 0.1, 1, 0);
spin = gwy_table_attach_hscale(table, row, _("Tip _rotation:"), _("deg"),
controls.theta, 0);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), 2);
row++;
controls.radius = gtk_adjustment_new(1.0, 0.01, 1000.0, 0.01, 1.0, 0.0);
controls.radius_spin = gtk_spin_button_new(GTK_ADJUSTMENT(controls.radius),
0.1, 2);
gtk_table_attach(GTK_TABLE(table), controls.radius_spin,
2, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
controls.radius_label = gtk_label_new_with_mnemonic(_("Tip _apex radius:"));
gtk_misc_set_alignment(GTK_MISC(controls.radius_label), 0.0, 0.5);
gtk_label_set_mnemonic_widget(GTK_LABEL(controls.radius_label),
controls.radius_spin);
gtk_table_attach(GTK_TABLE(table), controls.radius_label,
0, 1, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
unit = gwy_data_field_get_si_unit_xy(dfield);
controls.radius_unit
= gwy_combo_box_metric_unit_new(G_CALLBACK(radius_changed_cb),
&controls,
-12, -3, unit, -9);
gtk_table_attach(GTK_TABLE(table), controls.radius_unit,
3, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
g_signal_connect(controls.radius, "value-changed",
G_CALLBACK(radius_changed_cb), &controls);
row++;
controls.labsize = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(controls.labsize), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), controls.labsize,
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
controls.tipdone = FALSE;
tip_model_dialog_update_controls(&controls, args);
preview(&controls, args);
gtk_widget_show_all(dialog);
do {
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
tip_model_dialog_update_values(&controls, args);
gtk_widget_destroy(dialog);
tip_model_dialog_abandon(&controls);
case GTK_RESPONSE_NONE:
return;
break;
case GTK_RESPONSE_OK:
tip_model_do(args, &controls);
break;
case RESPONSE_RESET:
args->nsides = tip_model_defaults.nsides;
args->angle = tip_model_defaults.angle;
args->radius = tip_model_defaults.radius;
args->theta = tip_model_defaults.theta;
args->type = tip_model_defaults.type;
tip_model_dialog_update_controls(&controls, args);
break;
case RESPONSE_PREVIEW:
tip_model_dialog_update_values(&controls, args);
preview(&controls, args);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
tip_model_dialog_update_values(&controls, args);
gtk_widget_destroy(dialog);
tip_model_dialog_abandon(&controls);
}
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 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 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
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;
}
