static gboolean
gwy_graph_cursor_motion(GwyGraphWindow *graphwindow)
{
const gchar* xstring, *ystring;
GwyGraph *graph;
GwyAxis *axis;
gdouble x, y;
gchar buffer[200];
gdouble xmag, ymag;
graph = GWY_GRAPH(graphwindow->graph);
gwy_graph_area_get_cursor(GWY_GRAPH_AREA(gwy_graph_get_area(graph)),
&x, &y);
axis = gwy_graph_get_axis(graph, GTK_POS_TOP);
xmag = gwy_axis_get_magnification(axis);
xstring = gwy_axis_get_magnification_string(axis);
axis = gwy_graph_get_axis(graph, GTK_POS_LEFT);
ymag = gwy_axis_get_magnification(axis);
ystring = gwy_axis_get_magnification_string(axis);
g_snprintf(buffer, sizeof(buffer), "%.4f %s, %.4f %s",
x/xmag, xstring, y/ymag, ystring);
gwy_statusbar_set_markup(GWY_STATUSBAR(graphwindow->statusbar), buffer);
return FALSE;
}
static void
gwy_graph_window_zoom_finished(GwyGraphWindow *graphwindow)
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(graphwindow->button_zoom_in),
FALSE);
gwy_graph_set_status(GWY_GRAPH(graphwindow->graph),
graphwindow->last_status);
}
static void
gwy_graph_window_y_log(GwyGraphWindow *graphwindow)
{
GwyGraphModel *model;
gboolean state;
model = gwy_graph_get_model(GWY_GRAPH(graphwindow->graph));
g_object_get(model, "y-logarithmic", &state, NULL);
g_object_set(model, "y-logarithmic", !state, NULL);
}
static void
zoom_in_changed(EntropyControls *controls, GtkToggleButton *check)
{
GwyGraphModel *gmodel = gwy_graph_get_model(GWY_GRAPH(controls->graph));
GwyGraphCurveModel *gcmodel;
const gdouble *xdata, *ydata;
gdouble S;
guint ndata, i;
g_object_set(gmodel,
"x-min-set", FALSE,
"x-max-set", FALSE,
"y-min-set", FALSE,
"y-max-set", FALSE,
NULL);
if (!(controls->args->zoom_in = gtk_toggle_button_get_active(check))
|| (gwy_graph_model_get_n_curves(gmodel) < 2)) {
return;
}
gcmodel = gwy_graph_model_get_curve(gmodel, 1);
ydata = gwy_graph_curve_model_get_ydata(gcmodel);
S = ydata[0];
gcmodel = gwy_graph_model_get_curve(gmodel, 0);
ndata = gwy_graph_curve_model_get_ndata(gcmodel);
if (ndata < 5)
return;
xdata = gwy_graph_curve_model_get_xdata(gcmodel);
ydata = gwy_graph_curve_model_get_ydata(gcmodel);
for (i = 1; i+1 < ndata; i++) {
if (ydata[i] > S - G_LN2) {
g_object_set(gmodel,
"x-min", xdata[i-1],
"x-min-set", TRUE,
"y-min", ydata[i-1],
"y-min-set", TRUE,
NULL);
break;
}
}
for (i = ndata-2; i; i--) {
if (ydata[i] < S + G_LN2) {
g_object_set(gmodel,
"x-max", xdata[i+1],
"x-max-set", TRUE,
"y-max", ydata[i+1],
"y-max-set", TRUE,
NULL);
break;
}
}
}
static gboolean
height_dist(GwyContainer *data, GwyRunType run)
{
GString *lab;
GtkWidget *graph;
GwyDataWindow *data_window;
GwyGraphAutoProperties prop;
GwyDataLine *dataline;
GwyDataField *dfield;
GwyDataField *mfield;
GwySIValueFormat *units;
g_return_val_if_fail(run & DIST_RUN_MODES, FALSE);
g_return_val_if_fail(gwy_container_contains_by_name(data, "/0/mask"),
FALSE);
graph = gwy_graph_new();
gwy_graph_get_autoproperties(GWY_GRAPH(graph), &prop);
prop.is_point = 0;
prop.is_line = 1;
gwy_graph_set_autoproperties(GWY_GRAPH(graph), &prop);
dfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(data, "/0/data"));
mfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(data, "/0/mask"));
dataline = (GwyDataLine*)gwy_data_line_new(10, 10, TRUE);
gwy_data_field_grains_get_height_distribution(dfield, mfield, dataline);
lab = g_string_new(_("Grain height histogram"));
units = gwy_si_unit_get_format(dfield->si_unit_xy, dataline->real, NULL);
gwy_graph_add_dataline_with_units(GWY_GRAPH(graph), dataline, 0, lab, NULL,
units->magnitude, 1, units->units, " ");
data_window = gwy_app_data_window_get_for_data(data);
gwy_app_graph_window_create_for_window(GWY_GRAPH(graph), data_window,
_("Grain height distribution"));
g_string_free(lab, TRUE);
g_object_unref(dataline);
g_free(units);
return FALSE;
}
static gboolean
filter_target_graphs(GwyContainer *data, gint id, gpointer user_data)
{
GrainCrossControls *controls = (GrainCrossControls*)user_data;
GwyGraphModel *gmodel, *targetgmodel;
GQuark quark = gwy_app_get_graph_key_for_id(id);
gmodel = gwy_graph_get_model(GWY_GRAPH(controls->graph));
g_return_val_if_fail(GWY_IS_GRAPH_MODEL(gmodel), FALSE);
return (gwy_container_gis_object(data, quark, (GObject**)&targetgmodel)
&& gwy_graph_model_units_are_compatible(gmodel, targetgmodel));
}
static void
gwy_graph_window_zoom_in(GwyGraphWindow *graphwindow)
{
GwyGraph *graph;
graph = GWY_GRAPH(graphwindow->graph);
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(graphwindow->button_zoom_in))) {
graphwindow->last_status = gwy_graph_get_status(graph);
gwy_graph_set_status(graph, GWY_GRAPH_STATUS_ZOOM);
}
else
gwy_graph_set_status(graph, graphwindow->last_status);
}
static void
gwy_graph_window_zoom_to_fit(GwyGraphWindow *graphwindow)
{
GwyGraph *graph;
GwyGraphModel *model;
graph = GWY_GRAPH(graphwindow->graph);
model = gwy_graph_get_model(graph);
g_object_set(model,
"x-min-set", FALSE, "x-max-set", FALSE,
"y-min-set", FALSE, "y-max-set", FALSE,
NULL);
}
static void
gwy_graph_window_measure(GwyGraphWindow *graphwindow)
{
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(graphwindow->button_measure_points))) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(graphwindow->button_zoom_in), FALSE);
gwy_graph_set_status(GWY_GRAPH(graphwindow->graph),
GWY_GRAPH_STATUS_XLINES);
gtk_widget_queue_draw(graphwindow->graph);
gtk_widget_show_all(graphwindow->measure_dialog);
}
else {
gwy_graph_window_measure_finished(graphwindow, 0);
}
}
static void
gwy_graph_window_measure_finished(GwyGraphWindow *graphwindow, gint response)
{
GwyGraphArea *area;
area = GWY_GRAPH_AREA(gwy_graph_get_area(GWY_GRAPH(graphwindow->graph)));
/* XXX: Why, why, tell me why are *both* selections cleared when one clicks
* on clear and why it's done here instead of the dialog itself. */
gwy_selection_clear(gwy_graph_area_get_selection(area,
GWY_GRAPH_STATUS_POINTS));
gwy_selection_clear(gwy_graph_area_get_selection(area,
GWY_GRAPH_STATUS_XLINES));
if (response == GWY_GRAPH_WINDOW_MEASURE_RESPONSE_CLEAR)
return;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(graphwindow->button_measure_points), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(graphwindow->button_zoom_in), FALSE);
gwy_graph_set_status(GWY_GRAPH(graphwindow->graph), GWY_GRAPH_STATUS_PLAIN);
gtk_widget_queue_draw(graphwindow->graph);
gtk_widget_hide(graphwindow->measure_dialog);
}
static void
gwy_graph_window_copy_to_clipboard(GwyGraphWindow *graph_window)
{
GtkClipboard *clipboard;
GdkDisplay *display;
GdkPixbuf *pixbuf;
GdkAtom atom;
display = gtk_widget_get_display(GTK_WIDGET(graph_window));
atom = gdk_atom_intern("CLIPBOARD", FALSE);
clipboard = gtk_clipboard_get_for_display(display, atom);
pixbuf = gwy_graph_export_pixmap(GWY_GRAPH(graph_window->graph),
FALSE, TRUE, TRUE);
gtk_clipboard_set_image(clipboard, pixbuf);
g_object_unref(pixbuf);
}
static void
graph_title_changed(GwyGraphWindow *graphwindow)
{
GwyGraphModel *gmodel;
gchar *title;
gmodel = gwy_graph_get_model(GWY_GRAPH(graphwindow->graph));
g_object_get(gmodel, "title", &title, NULL);
/* FIXME: Can it be NULL? */
if (title)
gtk_window_set_title(GTK_WINDOW(graphwindow), title);
else
gtk_window_set_title(GTK_WINDOW(graphwindow), _("Untitled"));
g_free(title);
}
static void
reset(TipBlindControls *controls, TipBlindArgs *args)
{
GwyGraphModel *gmodel;
gwy_data_field_clear(controls->tip);
if (args->stripetips) {
guint i;
for (i = 0; i < controls->oldnstripes; i++)
gwy_data_field_clear(args->stripetips[i]);
}
controls->good_tip = FALSE;
gmodel = gwy_graph_model_new();
gwy_graph_set_model(GWY_GRAPH(controls->graph), gmodel);
g_object_unref(gmodel);
gtk_dialog_set_response_sensitive(GTK_DIALOG(controls->dialog),
GTK_RESPONSE_OK, controls->good_tip);
tip_update(controls);
}
static void
axis_quantity_changed(GrainCrossControls *controls)
{
GtkTreeSelection *selection;
GwyGraphModel *gmodel;
GwyGrainValue *gvalue;
GtkTreeModel *model;
GtkTreeIter iter;
gboolean ok;
ok = TRUE;
selection = gtk_tree_view_get_selection(controls->abscissa);
if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
gtk_tree_model_get(model, &iter,
GWY_GRAIN_VALUE_STORE_COLUMN_ITEM, &gvalue,
-1);
controls->args->abscissa = gwy_resource_get_name(GWY_RESOURCE(gvalue));
}
else
ok = FALSE;
selection = gtk_tree_view_get_selection(controls->ordinate);
if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
gtk_tree_model_get(model, &iter,
GWY_GRAIN_VALUE_STORE_COLUMN_ITEM, &gvalue,
-1);
controls->args->ordinate = gwy_resource_get_name(GWY_RESOURCE(gvalue));
}
else
ok = FALSE;
gmodel = create_corr_graph(controls->args, controls->dfield);
gwy_graph_set_model(GWY_GRAPH(controls->graph), gmodel);
g_object_unref(gmodel);
gtk_dialog_set_response_sensitive(controls->dialog, GTK_RESPONSE_OK, ok);
update_target_graphs(controls);
}
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 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
prof_dialog(ProfArgs *args,
GwyContainer *data,
GwyDataField *dfield,
gint id)
{
GtkWidget *hbox, *hbox2, *vbox, *label;
GwyDataChooser *chooser;
GtkTable *table;
GtkDialog *dialog;
GwyGraph *graph;
GwyGraphArea *area;
ProfControls controls;
gint response;
gint row;
controls.args = args;
controls.psdffield = prof_psdf(dfield, args);
controls.modfield = prof_sqrt(controls.psdffield);
controls.hx = gwy_data_field_get_xmeasure(dfield)/(2*G_PI);
controls.hy = gwy_data_field_get_xmeasure(dfield)/(2*G_PI);
controls.dialog = gtk_dialog_new_with_buttons(_("Radial PSDF Section"),
NULL, 0,
GTK_STOCK_CLEAR,
RESPONSE_CLEAR,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OK,
GTK_RESPONSE_OK,
NULL);
dialog = GTK_DIALOG(controls.dialog);
gtk_dialog_set_default_response(dialog, GTK_RESPONSE_OK);
gtk_dialog_set_response_sensitive(dialog, GTK_RESPONSE_OK, FALSE);
gwy_help_add_to_proc_dialog(GTK_DIALOG(dialog), GWY_HELP_DEFAULT);
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",
controls.modfield);
g_object_unref(controls.modfield);
gwy_container_set_string_by_name(controls.mydata, "/0/base/palette",
g_strdup("DFit"));
gwy_container_set_enum_by_name(controls.mydata, "/0/base/range-type",
GWY_LAYER_BASIC_RANGE_AUTO);
gwy_app_sync_data_items(data, controls.mydata, id, 0, FALSE,
GWY_DATA_ITEM_REAL_SQUARE,
0);
controls.view = create_preview(controls.mydata, 0, PREVIEW_SIZE, FALSE);
controls.selection = create_vector_layer(GWY_DATA_VIEW(controls.view), 0,
"Point", TRUE);
gwy_selection_set_max_objects(controls.selection, NLINES);
g_object_set(gwy_data_view_get_top_layer(GWY_DATA_VIEW(controls.view)),
"draw-as-vector", TRUE,
NULL);
g_signal_connect_swapped(controls.selection, "changed",
G_CALLBACK(prof_selection_changed), &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, 4);
controls.gmodel = gwy_graph_model_new();
g_object_set(controls.gmodel,
"title", _("PSDF Section"),
"axis-label-bottom", "k",
"axis-label-left", "W",
NULL);
init_graph_model_units(controls.gmodel, controls.psdffield);
controls.line = gwy_data_line_new(1, 1.0, FALSE);
controls.graph = gwy_graph_new(controls.gmodel);
graph = GWY_GRAPH(controls.graph);
gtk_widget_set_size_request(controls.graph, GRAPH_WIDTH, -1);
gwy_graph_set_axis_visible(graph, GTK_POS_LEFT, FALSE);
gwy_graph_set_axis_visible(graph, GTK_POS_RIGHT, FALSE);
gwy_graph_set_axis_visible(graph, GTK_POS_TOP, FALSE);
gwy_graph_set_axis_visible(graph, GTK_POS_BOTTOM, FALSE);
gwy_graph_enable_user_input(graph, FALSE);
area = GWY_GRAPH_AREA(gwy_graph_get_area(graph));
gwy_graph_area_enable_user_input(area, FALSE);
gtk_box_pack_start(GTK_BOX(vbox), controls.graph, TRUE, TRUE, 0);
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(vbox), GTK_WIDGET(table), FALSE, FALSE, 0);
row = 0;
controls.resolution = gtk_adjustment_new(controls.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 | GWY_HSCALE_SQRT);
g_signal_connect_swapped(controls.resolution, "value-changed",
G_CALLBACK(prof_resolution_changed), &controls);
controls.fixres = gwy_table_hscale_get_check(controls.resolution);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.fixres),
controls.args->fixres);
g_signal_connect_swapped(controls.fixres, "toggled",
G_CALLBACK(prof_fixres_changed), &controls);
gwy_table_hscale_set_sensitive(controls.resolution, controls.args->fixres);
row++;
controls.separate = gtk_check_button_new_with_mnemonic(_("_Separate curves"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.separate),
args->separate);
gtk_table_attach(table, controls.separate,
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
g_signal_connect_swapped(controls.separate, "toggled",
G_CALLBACK(prof_separate_changed), &controls);
row++;
hbox2 = gtk_hbox_new(FALSE, 6);
gtk_table_attach(table, hbox2,
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
label = gtk_label_new_with_mnemonic(_("_Interpolation type:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0);
controls.interpolation
= gwy_enum_combo_box_new(gwy_interpolation_type_get_enum(), -1,
G_CALLBACK(prof_interpolation_changed),
&controls,
controls.args->interpolation, TRUE);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), controls.interpolation);
gtk_box_pack_end(GTK_BOX(hbox2), controls.interpolation, FALSE, FALSE, 0);
row++;
controls.target_hbox = hbox2 = gtk_hbox_new(FALSE, 6);
gtk_widget_set_sensitive(hbox2, !args->separate);
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++;
gtk_widget_show_all(controls.dialog);
do {
response = gtk_dialog_run(dialog);
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
gtk_widget_destroy(controls.dialog);
case GTK_RESPONSE_NONE:
goto finalize;
break;
case GTK_RESPONSE_OK:
break;
case RESPONSE_CLEAR:
gwy_selection_clear(controls.selection);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
gtk_widget_destroy(controls.dialog);
prof_execute(&controls, data);
finalize:
g_object_unref(controls.psdffield);
g_object_unref(controls.mydata);
g_object_unref(controls.gmodel);
g_object_unref(controls.line);
}
static void
preview(EntropyControls *controls)
{
EntropyArgs *args = controls->args;
GwyDataField *dfield = controls->dfield;
GwyDataField *mfield = controls->mfield;
GwyGraphModel *gmodel;
GwyGraphCurveModel *gcmodel;
GwyDataLine *ecurve;
gchar buf[24];
gdouble S, s, Smax = 0.0;
ecurve = gwy_data_line_new(1, 1.0, FALSE);
if (args->mode == ENTROPY_VALUES) {
S = gwy_data_field_area_get_entropy_at_scales(dfield, ecurve,
mfield, args->masking,
0, 0,
dfield->xres,
dfield->yres,
0);
s = gwy_data_field_area_get_rms_mask(dfield,
mfield, args->masking,
0, 0, dfield->xres, dfield->yres);
Smax = ENTROPY_NORMAL + log(s);
}
else {
GwyDataField *xder = gwy_data_field_new_alike(dfield, FALSE);
GwyDataField *yder = gwy_data_field_new_alike(dfield, FALSE);
compute_slopes(controls->dfield,
args->fit_plane ? args->kernel_size : 0, xder, yder);
xder = fake_mask(xder, mfield, args->masking);
yder = fake_mask(yder, mfield, args->masking);
if (args->mode == ENTROPY_ANGLES)
transform_to_sphere(xder, yder);
S = gwy_data_field_get_entropy_2d_at_scales(xder, yder, ecurve, 0);
if (args->mode == ENTROPY_SLOPES) {
s = calculate_sigma2_2d(xder, yder);
Smax = ENTROPY_NORMAL_2D + log(s);
}
g_object_unref(xder);
g_object_unref(yder);
}
g_snprintf(buf, sizeof(buf), "%g", S);
gtk_label_set_text(GTK_LABEL(controls->entropy), buf);
if (args->mode != ENTROPY_ANGLES) {
g_snprintf(buf, sizeof(buf), "%g", Smax - S);
gtk_label_set_text(GTK_LABEL(controls->entropydef), buf);
}
else
gtk_label_set_text(GTK_LABEL(controls->entropydef), _("N.A."));
gmodel = gwy_graph_get_model(GWY_GRAPH(controls->graph));
gwy_graph_model_remove_all_curves(gmodel);
g_object_set(gmodel,
"axis-label-bottom", "log h",
"axis-label-left", "S",
"label-position", GWY_GRAPH_LABEL_NORTHWEST,
NULL);
if (gwy_data_line_get_min(ecurve) > -0.5*G_MAXDOUBLE) {
gcmodel = gwy_graph_curve_model_new();
g_object_set(gcmodel,
"description", _("Entropy at scales"),
"mode", GWY_GRAPH_CURVE_LINE_POINTS,
"color", gwy_graph_get_preset_color(0),
NULL);
gwy_graph_curve_model_set_data_from_dataline(gcmodel, ecurve, 0, 0);
gwy_graph_model_add_curve(gmodel, gcmodel);
g_object_unref(gcmodel);
}
if (S > -0.5*G_MAXDOUBLE) {
GwyDataLine *best = gwy_data_line_duplicate(ecurve);
gdouble *ydata = gwy_data_line_get_data(best);
guint i, res = gwy_data_line_get_res(best);
for (i = 0; i < res; i++)
ydata[i] = S;
gcmodel = gwy_graph_curve_model_new();
g_object_set(gcmodel,
"description", _("Best estimate"),
"mode", GWY_GRAPH_CURVE_LINE,
"color", gwy_graph_get_preset_color(1),
NULL);
gwy_graph_curve_model_set_data_from_dataline(gcmodel, best, 0, 0);
gwy_graph_model_add_curve(gmodel, gcmodel);
g_object_unref(gcmodel);
g_object_unref(best);
}
g_object_unref(ecurve);
zoom_in_changed(controls, GTK_TOGGLE_BUTTON(controls->zoom_in));
}
/**
* gwy_graph_window_new:
* @graph: A GwyGraph object containing the graph.
*
* Creates a new window showing @graph.
*
* Returns: A newly created graph window as #GtkWidget.
**/
GtkWidget*
gwy_graph_window_new(GwyGraph *graph)
{
GwyGraphWindow *graphwindow;
GwyGraphArea *area;
GwySelection *selection;
GtkScrolledWindow *swindow;
GtkWidget *vbox, *hbox;
GtkWidget *label;
gwy_debug("");
g_return_val_if_fail(GWY_IS_GRAPH(graph), NULL);
graphwindow = (GwyGraphWindow*)g_object_new(GWY_TYPE_GRAPH_WINDOW, NULL);
gtk_window_set_wmclass(GTK_WINDOW(graphwindow), "data",
g_get_application_name());
gtk_window_set_resizable(GTK_WINDOW(graphwindow), TRUE);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(GTK_WINDOW(graphwindow)), vbox);
graphwindow->graph = GTK_WIDGET(graph);
graphwindow->last_status = gwy_graph_get_status(graph);
/*add notebook with graph and text matrix*/
graphwindow->notebook = gtk_notebook_new();
graph_title_changed(graphwindow);
label = gtk_label_new(_("Graph"));
gtk_notebook_append_page(GTK_NOTEBOOK(graphwindow->notebook),
GTK_WIDGET(graph),
label);
swindow = GTK_SCROLLED_WINDOW(gtk_scrolled_window_new(NULL, NULL));
graphwindow->data = gwy_graph_data_new(gwy_graph_get_model(graph));
gtk_container_add(GTK_CONTAINER(swindow), graphwindow->data);
label = gtk_label_new(_("Data"));
gtk_notebook_append_page(GTK_NOTEBOOK(graphwindow->notebook),
GTK_WIDGET(swindow),
label);
gtk_container_add(GTK_CONTAINER(vbox), graphwindow->notebook);
/*add buttons*/
hbox = gtk_hbox_new(FALSE, 0);
graphwindow->button_measure_points = gtk_toggle_button_new();
gtk_container_add(GTK_CONTAINER(graphwindow->button_measure_points),
gtk_image_new_from_stock(GWY_STOCK_GRAPH_MEASURE,
GTK_ICON_SIZE_LARGE_TOOLBAR));
gtk_box_pack_start(GTK_BOX(hbox), graphwindow->button_measure_points,
FALSE, FALSE, 0);
gwy_graph_window_set_tooltip(graphwindow->button_measure_points,
_("Measure distances in graph"));
g_signal_connect_swapped(graphwindow->button_measure_points, "clicked",
G_CALLBACK(gwy_graph_window_measure),
graphwindow);
graphwindow->button_zoom_in = gtk_toggle_button_new();
gtk_container_add(GTK_CONTAINER(graphwindow->button_zoom_in),
gtk_image_new_from_stock(GWY_STOCK_GRAPH_ZOOM_IN,
GTK_ICON_SIZE_LARGE_TOOLBAR));
gtk_box_pack_start(GTK_BOX(hbox), graphwindow->button_zoom_in,
FALSE, FALSE, 0);
gwy_graph_window_set_tooltip(graphwindow->button_zoom_in,
_("Zoom in by mouse selection"));
g_signal_connect_swapped(graphwindow->button_zoom_in, "toggled",
G_CALLBACK(gwy_graph_window_zoom_in),
graphwindow);
graphwindow->button_zoom_to_fit = gtk_button_new();
gtk_container_add(GTK_CONTAINER(graphwindow->button_zoom_to_fit),
gtk_image_new_from_stock(GWY_STOCK_GRAPH_ZOOM_FIT,
GTK_ICON_SIZE_LARGE_TOOLBAR));
gtk_box_pack_start(GTK_BOX(hbox), graphwindow->button_zoom_to_fit,
FALSE, FALSE, 0);
gwy_graph_window_set_tooltip(graphwindow->button_zoom_to_fit,
_("Zoom out to full curve"));
g_signal_connect_swapped(graphwindow->button_zoom_to_fit, "clicked",
G_CALLBACK(gwy_graph_window_zoom_to_fit),
graphwindow);
graphwindow->button_x_log = gtk_toggle_button_new();
gtk_container_add(GTK_CONTAINER(graphwindow->button_x_log),
gtk_image_new_from_stock(GWY_STOCK_LOGSCALE_HORIZONTAL,
GTK_ICON_SIZE_LARGE_TOOLBAR));
gtk_box_pack_start(GTK_BOX(hbox), graphwindow->button_x_log,
FALSE, FALSE, 0);
gwy_graph_window_set_tooltip(graphwindow->button_x_log,
_("Toggle logarithmic x axis"));
g_signal_connect_swapped(graphwindow->button_x_log, "clicked",
G_CALLBACK(gwy_graph_window_x_log),
graphwindow);
gtk_widget_set_sensitive(graphwindow->button_x_log,
gwy_graph_model_x_data_can_be_logarithmed(graph->graph_model));
graphwindow->button_y_log = gtk_toggle_button_new();
gtk_container_add(GTK_CONTAINER(graphwindow->button_y_log),
gtk_image_new_from_stock(GWY_STOCK_LOGSCALE_VERTICAL,
GTK_ICON_SIZE_LARGE_TOOLBAR));
gtk_box_pack_start(GTK_BOX(hbox), graphwindow->button_y_log,
FALSE, FALSE, 0);
gwy_graph_window_set_tooltip(graphwindow->button_x_log,
_("Toggle logarithmic y axis"));
g_signal_connect_swapped(graphwindow->button_y_log, "clicked",
G_CALLBACK(gwy_graph_window_y_log),
graphwindow);
gtk_widget_set_sensitive(graphwindow->button_y_log,
gwy_graph_model_y_data_can_be_logarithmed(graph->graph_model));
graphwindow->statusbar = gwy_statusbar_new();
gtk_widget_set_name(graphwindow->statusbar, "gwyflatstatusbar");
gtk_box_pack_start(GTK_BOX(hbox), graphwindow->statusbar, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
graphwindow->measure_dialog = _gwy_graph_window_measure_dialog_new(graph);
g_signal_connect_swapped(graphwindow->measure_dialog, "response",
G_CALLBACK(gwy_graph_window_measure_finished),
graphwindow);
g_signal_connect_swapped(gwy_graph_get_area(graph), "motion-notify-event",
G_CALLBACK(gwy_graph_cursor_motion), graphwindow);
area = GWY_GRAPH_AREA(gwy_graph_get_area(graph));
selection = gwy_graph_area_get_selection(area, GWY_GRAPH_STATUS_ZOOM);
g_signal_connect_swapped(selection, "finished",
G_CALLBACK(gwy_graph_window_zoom_finished),
graphwindow);
if (gwy_graph_get_model(GWY_GRAPH(graphwindow->graph)))
g_signal_connect_swapped(gwy_graph_get_model(graph), "notify::title",
G_CALLBACK(graph_title_changed), graphwindow);
return GTK_WIDGET(graphwindow);
}