static void
preview(FacetsControls *controls,
FacetsArgs *args)
{
GwyDataField *dtheta, *dphi, *mask, *mfield = NULL;
GwyContainer *data, *fdata;
data = controls->mydata;
fdata = controls->fdata;
add_mask_field(GWY_DATA_VIEW(controls->view), NULL);
add_mask_field(GWY_DATA_VIEW(controls->fview), &mask_color);
mask = GWY_DATA_FIELD(gwy_container_get_object_by_name(data, "/0/mask"));
dtheta = GWY_DATA_FIELD(gwy_container_get_object_by_name(fdata, "/theta"));
dphi = GWY_DATA_FIELD(gwy_container_get_object_by_name(fdata, "/phi"));
gwy_container_gis_object_by_name(fdata, "/1/mask", (GObject**)&mfield);
gwy_data_field_mark_facets(dtheta, dphi, args->theta0, args->phi0,
args->tolerance, mask);
if (mfield && args->combine) {
if (args->combine_type == GWY_MERGE_UNION)
gwy_data_field_grains_add(mask, mfield);
else if (args->combine_type == GWY_MERGE_INTERSECTION)
gwy_data_field_grains_intersect(mask, mfield);
}
gwy_data_field_data_changed(mask);
facets_mark_fdata(args, fdata);
}
static void
mask_color_change_cb(GtkWidget *color_button,
WshedControls *controls)
{
gwy_color_selector_for_mask(NULL,
GWY_DATA_VIEW(controls->view),
GWY_COLOR_BUTTON(color_button),
NULL, "/0/mask");
load_mask_color(color_button,
gwy_data_view_get_data(GWY_DATA_VIEW(controls->view)));
}
/**
* gwy_vector_layer_draw:
* @layer: A vector data view layer.
* @drawable: A drawable to draw on.
* @target: Rendering target.
*
* Draws @layer on given drawable (which should be a #GwyDataView window).
**/
void
gwy_vector_layer_draw(GwyVectorLayer *layer,
GdkDrawable *drawable,
GwyRenderingTarget target)
{
GwyVectorLayerClass *layer_class = GWY_VECTOR_LAYER_GET_CLASS(layer);
GdkGC *gc = NULL;
g_assert(layer_class);
g_return_if_fail(layer_class->draw);
if (target == GWY_RENDERING_TARGET_PIXMAP_IMAGE) {
GwyDataView *data_view;
GdkGCValues gcvalues;
gint xres, yres, w, h;
gdouble zoom;
data_view = GWY_DATA_VIEW(GWY_DATA_VIEW_LAYER(layer)->parent);
g_return_if_fail(data_view);
gwy_data_view_get_pixel_data_sizes(data_view, &xres, &yres);
gdk_drawable_get_size(drawable, &w, &h);
zoom = sqrt(((gdouble)(w*h))/(xres*yres));
gc = gdk_gc_new(drawable);
gdk_gc_get_values(gc, &gcvalues);
gcvalues.line_width = ROUND(MAX(zoom, 1.0));
gcvalues.function = GDK_SET;
gdk_gc_set_values(gc, &gcvalues, GDK_GC_LINE_WIDTH | GDK_GC_FUNCTION);
GWY_SWAP(GdkGC*, layer->gc, gc);
}
static void
facet_view_selection_updated(GwySelection *selection,
G_GNUC_UNUSED gint id,
FacetsControls *controls)
{
GwyVectorLayer *layer;
const gchar *key;
gdouble theta, phi, x, y, q, xy[2];
gchar s[24];
q = gwy_container_get_double_by_name(controls->fdata, "/q");
gwy_selection_get_object(selection, 0, xy);
x = xy[0] - G_SQRT2/q;
y = xy[1] - G_SQRT2/q;
xy_to_angles(x, y, &theta, &phi);
g_snprintf(s, sizeof(s), "%.2f deg", 180.0/G_PI*theta);
gtk_label_set_text(GTK_LABEL(controls->theta_label), s);
controls->args->theta0 = theta;
g_snprintf(s, sizeof(s), "%.2f deg", 180.0/G_PI*phi);
gtk_label_set_text(GTK_LABEL(controls->phi_label), s);
controls->args->phi0 = phi;
if (!controls->in_update) {
layer = gwy_data_view_get_top_layer(GWY_DATA_VIEW(controls->view));
key = gwy_vector_layer_get_selection_key(layer);
selection = gwy_container_get_object_by_name(controls->mydata, key);
if (gwy_selection_get_data(selection, NULL))
gwy_selection_clear(selection);
}
controls->computed = FALSE;
}
static gboolean
immerse_view_expose(GtkWidget *view,
GdkEventExpose *event,
ImmerseControls *controls)
{
if (event->count > 0)
return FALSE;
if (controls->detail) {
GdkColor white = { 0, 0xffff, 0xffff, 0xffff };
GdkGC *gc;
gint w, h, xoff, yoff;
gwy_data_view_coords_real_to_xy(GWY_DATA_VIEW(view),
controls->args->xpos,
controls->args->ypos,
&xoff, &yoff);
w = gdk_pixbuf_get_width(controls->detail);
h = gdk_pixbuf_get_height(controls->detail);
/* gwy_debug("(%d,%d) %dx%d", xoff, yoff, w, h); */
gc = gdk_gc_new(view->window);
gdk_draw_pixbuf(view->window, gc, controls->detail,
0, 0, xoff, yoff, w, h,
GDK_RGB_DITHER_NORMAL, 0, 0);
if (controls->args->draw_frame) {
gdk_gc_set_function(gc, GDK_XOR);
gdk_gc_set_rgb_fg_color(gc, &white);
gdk_draw_rectangle(view->window, gc, FALSE, xoff, yoff, w-1, h-1);
}
g_object_unref(gc);
}
return FALSE;
}
static void
preview(GEdgeControls *controls,
GEdgeArgs *args)
{
GwyDataField *mask, *dfield;
GwyPixmapLayer *layer;
dfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(controls->mydata,
"/0/data"));
/* Set up the mask */
if (!gwy_container_gis_object_by_name(controls->mydata, "/0/mask", &mask)) {
mask = create_mask_field(dfield);
gwy_container_set_object_by_name(controls->mydata, "/0/mask", mask);
g_object_unref(mask);
layer = gwy_layer_mask_new();
gwy_pixmap_layer_set_data_key(layer, "/0/mask");
gwy_layer_mask_set_color_key(GWY_LAYER_MASK(layer), "/0/mask");
gwy_data_view_set_alpha_layer(GWY_DATA_VIEW(controls->view), layer);
}
gwy_data_field_copy(dfield, mask, FALSE);
gedge_process(dfield, mask, args);
gwy_data_field_data_changed(mask);
}
static void
unrotate_dialog_update(UnrotateControls *controls,
UnrotateArgs *args)
{
gchar *lab;
GwyPlaneSymmetry symm;
GwyDataField *dfield, *rfield;
GwyContainer *data;
gdouble phi;
gwy_enum_combo_box_set_active(GTK_COMBO_BOX(controls->interp),
args->interp);
gwy_enum_combo_box_set_active(GTK_COMBO_BOX(controls->symmetry),
args->symmetry);
symm = args->symmetry ? args->symmetry : controls->guess;
phi = controls->correction[symm];
lab = g_strdup_printf("%.2f %s", 180.0/G_PI*phi, _("deg"));
gtk_label_set_text(GTK_LABEL(controls->corrlabel), lab);
g_free(lab);
data = gwy_data_view_get_data(GWY_DATA_VIEW(controls->data_view));
dfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(data, "/0/data"));
rfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(data, "/0/show"));
gwy_data_field_copy(dfield, rfield, FALSE);
gwy_data_field_rotate(rfield, phi, args->interp);
gwy_data_field_data_changed(rfield);
}
static void
facet_view_recompute(GtkAdjustment *adj,
FacetsControls *controls)
{
GwyVectorLayer *layer;
GwyDataField *dfield;
GwySelection *selection;
const gchar *key;
controls->args->kernel_size = gwy_adjustment_get_int(adj);
gwy_app_wait_cursor_start(GTK_WINDOW(controls->dialog));
dfield = gwy_container_get_object_by_name(controls->mydata, "/0/data");
gwy_data_field_facet_distribution(dfield, 2*controls->args->kernel_size + 1,
controls->fdata);
/* XXX: Clear selections since we cannot recalculate it properly */
if (gwy_container_gis_object_by_name(controls->mydata, "/0/mask",
&dfield)) {
gwy_data_field_clear(dfield);
gwy_data_field_data_changed(dfield);
}
layer = gwy_data_view_get_top_layer(GWY_DATA_VIEW(controls->fview));
key = gwy_vector_layer_get_selection_key(layer);
selection = gwy_container_get_object_by_name(controls->fdata, key);
gwy_selection_clear(selection);
gwy_app_wait_cursor_finish(GTK_WINDOW(controls->dialog));
facets_invalidate(controls);
}
static void
preview(WshedControls *controls,
WshedArgs *args)
{
GwyDataField *maskfield, *dfield;
GwyPixmapLayer *layer;
dfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(controls->mydata,
"/0/data"));
/*set up the mask*/
if (gwy_container_contains_by_name(controls->mydata, "/0/mask")) {
maskfield
= GWY_DATA_FIELD(gwy_container_get_object_by_name(controls->mydata,
"/0/mask"));
gwy_data_field_resample(maskfield,
gwy_data_field_get_xres(dfield),
gwy_data_field_get_yres(dfield),
GWY_INTERPOLATION_NONE);
gwy_data_field_copy(dfield, maskfield);
if (!gwy_data_view_get_alpha_layer(GWY_DATA_VIEW(controls->view))) {
layer = GWY_PIXMAP_LAYER(gwy_layer_mask_new());
gwy_data_view_set_alpha_layer(GWY_DATA_VIEW(controls->view),
layer);
}
}
else {
maskfield
= GWY_DATA_FIELD(gwy_serializable_duplicate(G_OBJECT(dfield)));
gwy_container_set_object_by_name(controls->mydata, "/0/mask",
G_OBJECT(maskfield));
g_object_unref(maskfield);
layer = GWY_PIXMAP_LAYER(gwy_layer_mask_new());
gwy_data_view_set_alpha_layer(GWY_DATA_VIEW(controls->view),
layer);
}
wshed_dialog_update_values(controls, args);
controls->computed = mask_process(dfield, maskfield, args,
controls->dialog);
if (controls->computed)
gwy_data_view_update(GWY_DATA_VIEW(controls->view));
}
static void
mask_color_change_cb(GtkWidget *color_button,
FacetsControls *controls)
{
gwy_mask_color_selector_run(NULL, GTK_WINDOW(controls->dialog),
GWY_COLOR_BUTTON(color_button),
controls->mydata, "/0/mask");
load_mask_color(color_button,
gwy_data_view_get_data(GWY_DATA_VIEW(controls->view)));
}
static void
gwy_data_view_unrealize(GtkWidget *widget)
{
GwyDataView *data_view = GWY_DATA_VIEW(widget);
gwy_object_unref(data_view->pixbuf);
gwy_object_unref(data_view->base_pixbuf);
if (GTK_WIDGET_CLASS(parent_class)->unrealize)
GTK_WIDGET_CLASS(parent_class)->unrealize(widget);
}
static void
mask_color_changed(GtkWidget *color_button,
GFilterControls *controls)
{
GwyContainer *data;
data = gwy_data_view_get_data(GWY_DATA_VIEW(controls->view));
gwy_mask_color_selector_run(NULL, GTK_WINDOW(controls->dialog),
GWY_COLOR_BUTTON(color_button), data,
"/0/mask");
load_mask_color(color_button, data);
}
static gboolean
gwy_data_view_expose(GtkWidget *widget,
GdkEventExpose *event)
{
GwyDataView *data_view;
gint xs, ys, xe, ye, w, h;
GdkRectangle rect;
gboolean emit_redrawn = FALSE;
data_view = GWY_DATA_VIEW(widget);
gdk_region_get_clipbox(event->region, &rect);
gwy_debug("bbox = %dx%d at (%d,%d)",
rect.width, rect.height, rect.x, rect.y);
w = gdk_pixbuf_get_width(data_view->pixbuf);
h = gdk_pixbuf_get_height(data_view->pixbuf);
xs = MAX(rect.x, data_view->xoff) - data_view->xoff;
ys = MAX(rect.y, data_view->yoff) - data_view->yoff;
xe = MIN(rect.x + rect.width, data_view->xoff + w) - data_view->xoff;
ye = MIN(rect.y + rect.height, data_view->yoff + h) - data_view->yoff;
gwy_debug("going to draw: %dx%d at (%d,%d)",
xe - xs, ye - ys, xs, ys);
if (xs >= xe || ys >= ye)
return FALSE;
/* FIXME: ask the layers, if they want to repaint themselves */
if (data_view->force_update
|| gwy_data_view_layer_wants_repaint(data_view->base_layer)
|| gwy_data_view_layer_wants_repaint(data_view->alpha_layer)) {
gwy_data_view_paint(data_view);
emit_redrawn = TRUE;
}
data_view->force_update = FALSE;
gdk_draw_pixbuf(widget->window,
NULL,
data_view->pixbuf,
xs, ys,
xs + data_view->xoff, ys + data_view->yoff,
xe - xs, ye - ys,
GDK_RGB_DITHER_NORMAL,
0, 0);
if (data_view->top_layer)
gwy_vector_layer_draw(GWY_VECTOR_LAYER(data_view->top_layer),
widget->window);
if (emit_redrawn)
g_signal_emit(data_view, data_view_signals[REDRAWN], 0);
return FALSE;
}
static gboolean
gwy_data_view_key_release(GtkWidget *widget,
GdkEventKey *event)
{
GwyDataView *data_view;
g_return_val_if_fail(event, FALSE);
data_view = GWY_DATA_VIEW(widget);
if (!data_view->top_layer)
return FALSE;
return gwy_vector_layer_key_release(GWY_VECTOR_LAYER(data_view->top_layer), event);
}
static void
rotate_preview_draw(RotateControls *controls,
RotateArgs *args)
{
GwyDataField *dfield, *rfield;
GwyContainer *data;
data = gwy_data_view_get_data(GWY_DATA_VIEW(controls->data_view));
dfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(data, "/0/data"));
rfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(data, "/0/show"));
gwy_data_field_copy(dfield, rfield, FALSE);
gwy_data_field_rotate(rfield, args->angle, args->interp);
gwy_data_field_data_changed(rfield);
}
static gboolean
gwy_data_view_button_press(GtkWidget *widget,
GdkEventButton *event)
{
GwyDataView *data_view;
gwy_debug(" ");
g_return_val_if_fail(event, FALSE);
data_view = GWY_DATA_VIEW(widget);
if (!data_view->top_layer)
return FALSE;
return gwy_vector_layer_button_press(GWY_VECTOR_LAYER(data_view->top_layer), event);
}
/**
* gwy_data_view_new:
* @data: A #GwyContainer containing the data to display.
*
* Creates a new data-displaying widget for @data.
*
* A newly created #GwyDataView doesn't display anything. You have to add
* some layers to it, at least a base layer with
* gwy_data_view_set_base_layer(), and possibly others with
* gwy_data_view_set_alpha_layer() and gwy_data_view_set_top_layer().
*
* The top layer is special. It must be a vector layer and can receive
* mouse and keyboard events.
*
* The base layer it also special. It must be always present, and must not be
* transparent or vector.
*
* Returns: A newly created data view as a #GtkWidget.
**/
GtkWidget*
gwy_data_view_new(GwyContainer *data)
{
GtkWidget *data_view;
gwy_debug(" ");
g_return_val_if_fail(GWY_IS_CONTAINER(data), NULL);
data_view = gtk_widget_new(GWY_TYPE_DATA_VIEW, NULL);
g_object_ref(data);
GWY_DATA_VIEW(data_view)->data = data;
return data_view;
}
static void
preview(FacetsControls *controls,
FacetsArgs *args)
{
GwyDataField *dtheta, *dphi, *dfield, *mfield;
GwyContainer *data, *fdata;
data = controls->mydata;
fdata = controls->fdata;
add_mask_layer(GWY_DATA_VIEW(controls->view), NULL);
add_mask_layer(GWY_DATA_VIEW(controls->fview), &mask_color);
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"));
dtheta = GWY_DATA_FIELD(gwy_container_get_object_by_name(fdata, "/theta"));
dphi = GWY_DATA_FIELD(gwy_container_get_object_by_name(fdata, "/phi"));
gwy_data_field_mark_facets(dtheta, dphi, args->theta0, args->phi0,
args->tolerance, mfield);
gwy_data_field_data_changed(mfield);
facets_mark_fdata(args, fdata);
facets_invalidate(controls);
}
static gboolean
immerse_view_inside_detail(ImmerseControls *controls,
gint x, gint y)
{
gint xoff, yoff;
if (!controls->detail)
return FALSE;
gwy_data_view_coords_real_to_xy(GWY_DATA_VIEW(controls->view),
controls->args->xpos,
controls->args->ypos,
&xoff, &yoff);
return (x >= xoff
&& x < xoff + gdk_pixbuf_get_width(controls->detail)
&& y >= yoff
&& y < yoff + gdk_pixbuf_get_height(controls->detail));
}
static void
gwy_data_view_destroy(GtkObject *object)
{
GwyDataView *data_view;
gwy_debug("destroying a GwyDataView %p (refcount = %u)",
object, G_OBJECT(object)->ref_count);
g_return_if_fail(GWY_IS_DATA_VIEW(object));
data_view = GWY_DATA_VIEW(object);
gwy_data_view_set_layer(data_view, &data_view->top_layer, NULL);
gwy_data_view_set_layer(data_view, &data_view->alpha_layer, NULL);
gwy_data_view_set_layer(data_view, &data_view->base_layer, NULL);
if (GTK_OBJECT_CLASS(parent_class)->destroy)
(*GTK_OBJECT_CLASS(parent_class)->destroy)(object);
}
static void
apply(GwyUnitoolState *state)
{
static const gchar *field_names[] = { "/0/data", "/0/mask", "/0/show" };
GtkWidget *data_window;
GwyDataView *data_view;
GwyContainer *data;
GwyDataField *dfield;
gint ximin, yimin, ximax, yimax;
gdouble sel[4];
gsize i;
if (!gwy_vector_layer_get_selection(state->layer, sel))
return;
data_view = GWY_DATA_VIEW(GWY_DATA_VIEW_LAYER(state->layer)->parent);
data = gwy_data_view_get_data(data_view);
data = GWY_CONTAINER(gwy_serializable_duplicate(G_OBJECT(data)));
gwy_app_clean_up_data(data);
for (i = 0; i < G_N_ELEMENTS(field_names); i++) {
if (!gwy_container_gis_object_by_name(data, field_names[i],
(GObject**)&dfield))
continue;
ximin = gwy_data_field_rtoj(dfield, sel[0]);
yimin = gwy_data_field_rtoi(dfield, sel[1]);
ximax = gwy_data_field_rtoj(dfield, sel[2]) + 1;
yimax = gwy_data_field_rtoi(dfield, sel[3]) + 1;
gwy_data_field_set_xreal(dfield,
(ximax - ximin)
*gwy_data_field_get_xreal(dfield)
/gwy_data_field_get_xres(dfield));
gwy_data_field_set_yreal(dfield,
(yimax - yimin)
*gwy_data_field_get_yreal(dfield)
/gwy_data_field_get_yres(dfield));
gwy_data_field_resize(dfield, ximin, yimin, ximax, yimax);
}
data_window = gwy_app_data_window_create(data);
gwy_app_data_window_set_untitled(GWY_DATA_WINDOW(data_window), NULL);
gwy_vector_layer_unselect(state->layer);
gwy_data_view_update(data_view);
gwy_debug("%d %d",
gwy_data_field_get_xres(dfield), gwy_data_field_get_yres(dfield));
}
static void
immerse_update_detail_pixbuf(ImmerseControls *controls)
{
GwyContainer *data;
GwyDataField *dfield;
GwyGradient *gradient;
GdkPixbuf *pixbuf;
const guchar *name;
gchar *key;
GQuark quark;
gint w, h, xres, yres;
GWY_OBJECT_UNREF(controls->detail);
data = gwy_app_data_browser_get(controls->args->detail.datano);
if (!data)
return;
quark = gwy_app_get_data_key_for_id(controls->args->detail.id);
dfield = gwy_container_get_object(data, quark);
gwy_data_view_coords_real_to_xy(GWY_DATA_VIEW(controls->view),
gwy_data_field_get_xreal(dfield),
gwy_data_field_get_yreal(dfield),
&w, &h);
gwy_debug("%dx%d", w, h);
w = MAX(w, 2);
h = MAX(h, 2);
key = g_strdup_printf("/%d/base/palette", controls->args->image.id);
name = NULL;
data = gwy_app_data_browser_get(controls->args->image.datano);
gwy_container_gis_string_by_name(data, key, &name);
g_free(key);
gradient = gwy_gradients_get_gradient(name);
/* Handle real-square properly by using an intermediate
* pixel-square pixbuf with sufficient resolution */
xres = gwy_data_field_get_xres(dfield);
yres = gwy_data_field_get_yres(dfield);
pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8, xres, yres);
gwy_pixbuf_draw_data_field(pixbuf, dfield, gradient);
controls->detail = gdk_pixbuf_scale_simple(pixbuf, w, h, GDK_INTERP_TILES);
g_object_unref(pixbuf);
}
static void
gwy_data_view_realize(GtkWidget *widget)
{
GwyDataView *data_view;
GdkWindowAttr attributes;
gint attributes_mask;
gwy_debug("realizing a GwyDataView (%ux%u)",
widget->allocation.width, widget->allocation.height);
g_return_if_fail(widget != NULL);
GTK_WIDGET_SET_FLAGS(widget, GTK_REALIZED);
data_view = GWY_DATA_VIEW(widget);
attributes.x = widget->allocation.x;
attributes.y = widget->allocation.y;
attributes.width = widget->allocation.width;
attributes.height = widget->allocation.height;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.window_type = GDK_WINDOW_CHILD;
attributes.event_mask = gtk_widget_get_events(widget)
| GDK_EXPOSURE_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_KEY_PRESS_MASK
| GDK_KEY_RELEASE_MASK
| GDK_POINTER_MOTION_MASK
| GDK_POINTER_MOTION_HINT_MASK;
attributes.visual = gtk_widget_get_visual(widget);
attributes.colormap = gtk_widget_get_colormap(widget);
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
widget->window = gdk_window_new(gtk_widget_get_parent_window(widget),
&attributes, attributes_mask);
gdk_window_set_user_data(widget->window, widget);
widget->style = gtk_style_attach(widget->style, widget->window);
gtk_style_set_background(widget->style, widget->window, GTK_STATE_NORMAL);
gwy_data_view_make_pixmap(data_view);
}
static void
gwy_data_view_finalize(GObject *object)
{
GwyDataView *data_view;
gwy_debug("finalizing a GwyDataView (refcount = %u)",
object->ref_count);
g_return_if_fail(GWY_IS_DATA_VIEW(object));
data_view = GWY_DATA_VIEW(object);
gwy_object_unref(data_view->base_layer);
gwy_object_unref(data_view->alpha_layer);
gwy_object_unref(data_view->top_layer);
gwy_debug(" child data ref count %d", G_OBJECT(data_view->data)->ref_count);
gwy_object_unref(data_view->data);
G_OBJECT_CLASS(parent_class)->finalize(object);
}
static void
selection_changed(GtkWidget *button,
RHKControls *controls)
{
RHKPage *rhkpage;
GwyDataField *dfield;
guint i;
if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button)))
return;
i = gwy_radio_buttons_get_current_from_widget(button, "data");
g_assert(i != (guint)-1);
rhkpage = g_ptr_array_index(controls->file, i);
dfield = rhk_sm3_page_to_data_field(rhkpage);
gwy_container_set_object_by_name(controls->data, "/0/data",
(GObject*)dfield);
g_object_unref(dfield);
gwy_data_view_update(GWY_DATA_VIEW(controls->data_view));
}
static void
facet_view_select_angle(FacetsControls *controls,
gdouble theta,
gdouble phi)
{
gdouble x, y, q, xy[2];
GwyVectorLayer *layer;
GwySelection *selection;
const gchar *key;
angles_to_xy(theta, phi, &x, &y);
controls->in_update = TRUE;
q = gwy_container_get_double_by_name(controls->fdata, "/q");
xy[0] = x + G_SQRT2/q;
xy[1] = y + G_SQRT2/q;
layer = gwy_data_view_get_top_layer(GWY_DATA_VIEW(controls->fview));
key = gwy_vector_layer_get_selection_key(layer);
selection = gwy_container_get_object_by_name(controls->fdata, key);
gwy_selection_set_object(selection, 0, xy);
controls->in_update = FALSE;
}
static gboolean
immerse_view_button_release(GtkWidget *view,
GdkEventButton *event,
ImmerseControls *controls)
{
gdouble xpos, ypos;
if (event->button != controls->button)
return FALSE;
controls->button = 0;
gwy_data_view_coords_xy_to_real(GWY_DATA_VIEW(view),
event->x - controls->xc,
event->y - controls->yc,
&xpos,
&ypos);
immerse_clamp_detail_offset(controls, xpos, ypos);
gdk_window_set_cursor(view->window, controls->near_cursor);
return TRUE;
}
static void
gwy_data_view_size_request(GtkWidget *widget,
GtkRequisition *requisition)
{
GwyDataView *data_view;
GwyContainer *data;
GwyDataField *data_field;
gwy_debug(" ");
data_view = GWY_DATA_VIEW(widget);
data = data_view->data;
/* TODO Container */
data_field = GWY_DATA_FIELD(gwy_container_get_object_by_name(data,
"/0/data"));
requisition->width = data_view->newzoom
* gwy_data_field_get_xres(data_field);
requisition->height = data_view->newzoom
* gwy_data_field_get_yres(data_field);
gwy_debug("requesting %d x %d",
requisition->width, requisition->height);
}
static gboolean
immerse_view_button_press(GtkWidget *view,
GdkEventButton *event,
ImmerseControls *controls)
{
gint xoff, yoff;
if (event->button != 1
|| !immerse_view_inside_detail(controls, event->x, event->y))
return FALSE;
gwy_data_view_coords_real_to_xy(GWY_DATA_VIEW(view),
controls->args->xpos,
controls->args->ypos,
&xoff, &yoff);
controls->button = event->button;
/* Cursor offset wrt top left corner */
controls->xc = event->x - xoff;
controls->yc = event->y - yoff;
gdk_window_set_cursor(view->window, controls->move_cursor);
return TRUE;
}
static gboolean
immerse_view_motion_notify(GtkWidget *view,
GdkEventMotion *event,
ImmerseControls *controls)
{
GdkWindow *window;
gint x, y;
if (!controls->detail)
return FALSE;
window = view->window;
if (event->is_hint)
gdk_window_get_pointer(window, &x, &y, NULL);
else {
x = event->x;
y = event->y;
}
if (!controls->button) {
if (immerse_view_inside_detail(controls, x, y))
gdk_window_set_cursor(window, controls->near_cursor);
else
gdk_window_set_cursor(window, NULL);
}
else {
gdouble xpos, ypos;
gwy_data_view_coords_xy_to_real(GWY_DATA_VIEW(view),
x - controls->xc,
y - controls->yc,
&xpos, &ypos);
immerse_clamp_detail_offset(controls, xpos, ypos);
}
return TRUE;
}
