static int dt_circle_events_mouse_scrolled(struct dt_iop_module_t *module, float pzx, float pzy, int up, uint32_t state,
dt_masks_form_t *form, int parentid, dt_masks_form_gui_t *gui, int index)
{
if (gui->form_selected)
{
//we register the current position
if (gui->scrollx == 0.0f && gui->scrolly == 0.0f)
{
gui->scrollx = pzx;
gui->scrolly = pzy;
}
if ((state&GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
{
//we try to change the opacity
dt_masks_form_change_opacity(form,parentid,up);
}
else
{
dt_masks_point_circle_t *circle = (dt_masks_point_circle_t *) (g_list_first(form->points)->data);
if (gui->border_selected)
{
if(up && circle->border > 0.002f) circle->border *= 0.97f;
else if(circle->border < 1.0f ) circle->border *= 1.0f/0.97f;
dt_masks_write_form(form,darktable.develop);
dt_masks_gui_form_remove(form,gui,index);
dt_masks_gui_form_create(form,gui,index);
if (form->type & DT_MASKS_CLONE)
dt_conf_set_float("plugins/darkroom/spots/circle_border", circle->border);
else
dt_conf_set_float("plugins/darkroom/masks/circle/border", circle->border);
}
else if (gui->edit_mode == DT_MASKS_EDIT_FULL)
{
if(up && circle->radius > 0.002f) circle->radius *= 0.97f;
else if(circle->radius < 1.0f ) circle->radius *= 1.0f/0.97f;
dt_masks_write_form(form,darktable.develop);
dt_masks_gui_form_remove(form,gui,index);
dt_masks_gui_form_create(form,gui,index);
if (form->type & DT_MASKS_CLONE)
dt_conf_set_float("plugins/darkroom/spots/circle_size", circle->radius);
else
dt_conf_set_float("plugins/darkroom/masks/circle/size", circle->radius);
}
else
{
return 0;
}
dt_masks_update_image(darktable.develop);
}
return 1;
}
return 0;
}
static int dt_gradient_events_mouse_scrolled(struct dt_iop_module_t *module, float pzx, float pzy, int up, uint32_t state,
dt_masks_form_t *form, int parentid, dt_masks_form_gui_t *gui, int index)
{
if (gui->form_selected)
{
//we register the current position
if (gui->scrollx == 0.0f && gui->scrolly == 0.0f)
{
gui->scrollx = pzx;
gui->scrolly = pzy;
}
if ((state&GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
{
//we try to change the opacity
dt_masks_form_change_opacity(form,parentid,up);
}
else if(gui->edit_mode == DT_MASKS_EDIT_FULL)
{
dt_masks_point_gradient_t *gradient = (dt_masks_point_gradient_t *) (g_list_first(form->points)->data);
if(up) gradient->compression = fmaxf(gradient->compression, 0.001f) * 0.8f;
else gradient->compression = fminf(fmaxf(gradient->compression, 0.001f) * 1.0f/0.8f, 1.0f);
dt_masks_write_form(form,darktable.develop);
dt_masks_gui_form_remove(form,gui,index);
dt_masks_gui_form_create(form,gui,index);
dt_conf_set_float("plugins/darkroom/masks/gradient/compression", gradient->compression);
dt_masks_update_image(darktable.develop);
}
return 1;
}
return 0;
}
static void colorpick_color_set(GtkColorButton *widget, gpointer user_data)
{
dt_iop_module_t *self = (dt_iop_module_t *)user_data;
if(self->dt->gui->reset) return;
dt_iop_watermark_params_t *p = (dt_iop_watermark_params_t *)self->params;
GdkRGBA c;
gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(widget), &c);
p->color[0] = c.red;
p->color[1] = c.green;
p->color[2] = c.blue;
dt_conf_set_float("plugins/darkroom/watermark/color_red", p->color[0]);
dt_conf_set_float("plugins/darkroom/watermark/color_green", p->color[1]);
dt_conf_set_float("plugins/darkroom/watermark/color_blue", p->color[2]);
dt_dev_add_history_item(darktable.develop, self, TRUE);
}
static float dt_conf_get_sanitize_set(const char *name, float min, float max)
{
float value = dt_conf_get_float(name);
value = MIN(max, value);
value = MAX(min, value);
dt_conf_set_float(name, value);
return value;
}
int scrolled(dt_iop_module_t *self, double x, double y, int up, uint32_t state)
{
dt_iop_spots_params_t *p = (dt_iop_spots_params_t *)self->params;
dt_iop_spots_gui_data_t *g = (dt_iop_spots_gui_data_t *)self->gui_data;
if(g->selected >= 0)
{
if(up && p->spot[g->selected].radius > 0.002f) p->spot[g->selected].radius *= 0.9f;
else if(p->spot[g->selected].radius < 0.1f ) p->spot[g->selected].radius *= 1.0f/0.9f;
g->last_radius = p->spot[g->selected].radius;
dt_conf_set_float("plugins/darkroom/spots/size", g->last_radius);
dt_dev_add_history_item(darktable.develop, self, TRUE);
return 1;
}
return 0;
}
static void _view_map_post_expose(cairo_t *cri, int32_t width_i, int32_t height_i,
int32_t pointerx, int32_t pointery, gpointer user_data)
{
const int ts = 64;
OsmGpsMapPoint bb[2], *l=NULL, *center=NULL;
int px,py;
dt_map_t *lib = (dt_map_t *)user_data;
/* get bounding box coords */
osm_gps_map_get_bbox(lib->map, &bb[0], &bb[1]);
float bb_0_lat = 0.0, bb_0_lon = 0.0, bb_1_lat = 0.0, bb_1_lon = 0.0;
osm_gps_map_point_get_degrees(&bb[0], &bb_0_lat, &bb_0_lon);
osm_gps_map_point_get_degrees(&bb[1], &bb_1_lat, &bb_1_lon);
/* make the bounding box a little bigger to the west and south */
float lat0 = 0.0, lon0 = 0.0, lat1 = 0.0, lon1 = 0.0;
OsmGpsMapPoint *pt0 = osm_gps_map_point_new_degrees(0.0, 0.0), *pt1 = osm_gps_map_point_new_degrees(0.0, 0.0);
osm_gps_map_convert_screen_to_geographic(lib->map, 0, 0, pt0);
osm_gps_map_convert_screen_to_geographic(lib->map, 1.5*ts, 1.5*ts, pt1);
osm_gps_map_point_get_degrees(pt0, &lat0, &lon0);
osm_gps_map_point_get_degrees(pt1, &lat1, &lon1);
osm_gps_map_point_free(pt0);
osm_gps_map_point_free(pt1);
double south_border = lat0 - lat1, west_border = lon1 - lon0;
/* get map view state and store */
int zoom = osm_gps_map_get_zoom(lib->map);
center = osm_gps_map_get_center(lib->map);
dt_conf_set_float("plugins/map/longitude", center->rlon);
dt_conf_set_float("plugins/map/latitude", center->rlat);
dt_conf_set_int("plugins/map/zoom", zoom);
osm_gps_map_point_free(center);
/* let's reset and reuse the main_query statement */
DT_DEBUG_SQLITE3_CLEAR_BINDINGS(lib->statements.main_query);
DT_DEBUG_SQLITE3_RESET(lib->statements.main_query);
/* bind bounding box coords for the main query */
DT_DEBUG_SQLITE3_BIND_DOUBLE(lib->statements.main_query, 1, bb_0_lon - west_border);
DT_DEBUG_SQLITE3_BIND_DOUBLE(lib->statements.main_query, 2, bb_1_lon);
DT_DEBUG_SQLITE3_BIND_DOUBLE(lib->statements.main_query, 3, bb_0_lat);
DT_DEBUG_SQLITE3_BIND_DOUBLE(lib->statements.main_query, 4, bb_1_lat - south_border);
/* query collection ids */
while(sqlite3_step(lib->statements.main_query) == SQLITE_ROW)
{
int32_t imgid = sqlite3_column_int(lib->statements.main_query, 0);
cairo_set_source_rgba(cri, 0, 0, 0, 0.4);
/* free l if allocated */
if (l)
osm_gps_map_point_free(l);
/* for each image check if within bbox */
const dt_image_t *cimg = dt_image_cache_read_get(darktable.image_cache, imgid);
double longitude = cimg->longitude;
double latitude = cimg->latitude;
dt_image_cache_read_release(darktable.image_cache, cimg);
if(isnan(latitude) || isnan(longitude))
continue;
l = osm_gps_map_point_new_degrees(latitude, longitude);
/* translate l into screen coords */
osm_gps_map_convert_geographic_to_screen(lib->map, l, &px, &py);
/* dependent on scale draw different overlays */
if (zoom >= 14)
{
dt_mipmap_buffer_t buf;
dt_mipmap_size_t mip = dt_mipmap_cache_get_matching_size(darktable.mipmap_cache, ts, ts);
dt_mipmap_cache_read_get(darktable.mipmap_cache, &buf, imgid, mip, 0);
cairo_surface_t *surface = NULL;
if(buf.buf)
{
float ms = fminf(
ts/(float)buf.width,
ts/(float)buf.height);
#if 0
// this doesn't work since osm-gps-map always gives 0/0 as mouse coords :(
/* find out if the cursor is over the image */
if(pointerx >= px && pointerx <= (px + buf.width*ms + 4) && pointery <= (py - 8) && pointery >= (py - buf.height*ms - 8 - 4))
{
printf("over\n");
cairo_set_source_rgba(cri, 1, 0, 0, 0.7);
}
// else
// printf("%d/%d, %d/%d\n", px, py, pointerx, pointery);
#endif
const int32_t stride = cairo_format_stride_for_width (CAIRO_FORMAT_RGB24, buf.width);
surface = cairo_image_surface_create_for_data (buf.buf, CAIRO_FORMAT_RGB24,
buf.width, buf.height, stride);
cairo_pattern_set_filter(cairo_get_source(cri), CAIRO_FILTER_NEAREST);
cairo_save(cri);
/* first of lets draw a pin */
cairo_move_to(cri, px, py);
cairo_line_to(cri, px+8, py-8);
cairo_line_to(cri, px+4, py-8);
cairo_fill(cri);
/* and the frame around image */
cairo_move_to(cri, px+2, py-8);
cairo_line_to(cri, px+2 + (buf.width*ms) + 4, py-8);
cairo_line_to(cri, px+2 + (buf.width*ms) + 4 , py-8-(buf.height*ms) - 4);
cairo_line_to(cri, px+2 , py-8-(buf.height*ms) - 4);
cairo_fill(cri);
/* draw image*/
cairo_translate(cri, px+4, py - 8 - (buf.height*ms) - 2);
cairo_scale(cri, ms, ms);
cairo_set_source_surface (cri, surface, 0, 0);
cairo_paint(cri);
cairo_restore(cri);
cairo_surface_destroy(surface);
}
}
else
{
/* just draw a patch indicating that there is images at the location */
cairo_rectangle(cri, px-8, py-8, 16, 16);
cairo_fill(cri);
}
}
}
static void _view_map_changed_callback(OsmGpsMap *map, dt_view_t *self)
{
dt_map_t *lib = (dt_map_t *)self->data;
const int ts = 64;
OsmGpsMapPoint bb[2];
/* get bounding box coords */
osm_gps_map_get_bbox(map, &bb[0], &bb[1]);
float bb_0_lat = 0.0, bb_0_lon = 0.0, bb_1_lat = 0.0, bb_1_lon = 0.0;
osm_gps_map_point_get_degrees(&bb[0], &bb_0_lat, &bb_0_lon);
osm_gps_map_point_get_degrees(&bb[1], &bb_1_lat, &bb_1_lon);
/* make the bounding box a little bigger to the west and south */
float lat0 = 0.0, lon0 = 0.0, lat1 = 0.0, lon1 = 0.0;
OsmGpsMapPoint *pt0 = osm_gps_map_point_new_degrees(0.0, 0.0), *pt1 = osm_gps_map_point_new_degrees(0.0, 0.0);
osm_gps_map_convert_screen_to_geographic(map, 0, 0, pt0);
osm_gps_map_convert_screen_to_geographic(map, 1.5*ts, 1.5*ts, pt1);
osm_gps_map_point_get_degrees(pt0, &lat0, &lon0);
osm_gps_map_point_get_degrees(pt1, &lat1, &lon1);
osm_gps_map_point_free(pt0);
osm_gps_map_point_free(pt1);
double south_border = lat0 - lat1, west_border = lon1 - lon0;
/* get map view state and store */
int zoom;
float center_lat, center_lon;
g_object_get(G_OBJECT(map), "zoom", &zoom, "latitude", ¢er_lat, "longitude", ¢er_lon, NULL);
dt_conf_set_float("plugins/map/longitude", center_lon);
dt_conf_set_float("plugins/map/latitude", center_lat);
dt_conf_set_int("plugins/map/zoom", zoom);
/* let's reset and reuse the main_query statement */
DT_DEBUG_SQLITE3_CLEAR_BINDINGS(lib->statements.main_query);
DT_DEBUG_SQLITE3_RESET(lib->statements.main_query);
/* bind bounding box coords for the main query */
DT_DEBUG_SQLITE3_BIND_DOUBLE(lib->statements.main_query, 1, bb_0_lon - west_border);
DT_DEBUG_SQLITE3_BIND_DOUBLE(lib->statements.main_query, 2, bb_1_lon);
DT_DEBUG_SQLITE3_BIND_DOUBLE(lib->statements.main_query, 3, bb_0_lat);
DT_DEBUG_SQLITE3_BIND_DOUBLE(lib->statements.main_query, 4, bb_1_lat - south_border);
DT_DEBUG_SQLITE3_BIND_DOUBLE(lib->statements.main_query, 5, center_lat);
DT_DEBUG_SQLITE3_BIND_DOUBLE(lib->statements.main_query, 6, center_lon);
/* remove the old images */
osm_gps_map_image_remove_all(map);
if(lib->images)
{
g_slist_foreach(lib->images, (GFunc) g_free, NULL);
g_slist_free(lib->images);
lib->images = NULL;
}
/* add all images to the map */
gboolean needs_redraw = FALSE;
dt_mipmap_size_t mip = dt_mipmap_cache_get_matching_size(darktable.mipmap_cache, ts, ts);
while(sqlite3_step(lib->statements.main_query) == SQLITE_ROW)
{
int imgid = sqlite3_column_int(lib->statements.main_query, 0);
dt_mipmap_buffer_t buf;
dt_mipmap_cache_read_get(darktable.mipmap_cache, &buf, imgid, mip, DT_MIPMAP_BEST_EFFORT);
if(buf.buf)
{
uint8_t *scratchmem = dt_mipmap_cache_alloc_scratchmem(darktable.mipmap_cache);
uint8_t *buf_decompressed = dt_mipmap_cache_decompress(&buf, scratchmem);
uint8_t *rgbbuf = g_malloc((buf.width+2)*(buf.height+2)*3);
memset(rgbbuf, 64, (buf.width+2)*(buf.height+2)*3);
for(int i=1; i<=buf.height; i++)
for(int j=1; j<=buf.width; j++)
for(int k=0; k<3; k++)
rgbbuf[(i*(buf.width+2)+j)*3+k] = buf_decompressed[((i-1)*buf.width+j-1)*4+2-k];
int w=ts, h=ts;
if(buf.width < buf.height) w = (buf.width*ts)/buf.height; // portrait
else h = (buf.height*ts)/buf.width; // landscape
GdkPixbuf *source = gdk_pixbuf_new_from_data(rgbbuf, GDK_COLORSPACE_RGB, FALSE, 8, (buf.width+2), (buf.height+2), (buf.width+2)*3, NULL, NULL);
GdkPixbuf *scaled = gdk_pixbuf_scale_simple(source, w, h, GDK_INTERP_HYPER);
//TODO: add back the arrow on the left lower corner of the image, pointing to the location
const dt_image_t *cimg = dt_image_cache_read_get(darktable.image_cache, imgid);
dt_map_image_t *entry = (dt_map_image_t*)g_malloc(sizeof(dt_map_image_t));
entry->imgid = imgid;
entry->image = osm_gps_map_image_add_with_alignment(map, cimg->latitude, cimg->longitude, scaled, 0, 1);
entry->width = w;
entry->height = h;
lib->images = g_slist_prepend(lib->images, entry);
dt_image_cache_read_release(darktable.image_cache, cimg);
if(source)
g_object_unref(source);
if(scaled)
g_object_unref(scaled);
g_free(rgbbuf);
}
else
needs_redraw = TRUE;
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
}
// not exactly thread safe, but should be good enough for updating the display
static int timeout_event_source = 0;
if(needs_redraw && timeout_event_source == 0)
timeout_event_source = g_timeout_add_seconds(1, _view_map_redraw, self); // try again in a second, maybe some pictures have loaded by then
else
timeout_event_source = 0;
}
static int dt_ellipse_events_button_released(struct dt_iop_module_t *module, float pzx, float pzy, int which,
uint32_t state, dt_masks_form_t *form, int parentid,
dt_masks_form_gui_t *gui, int index)
{
if(which == 3 && parentid > 0 && gui->edit_mode == DT_MASKS_EDIT_FULL)
{
// we hide the form
if(!(darktable.develop->form_visible->type & DT_MASKS_GROUP))
dt_masks_change_form_gui(NULL);
else if(g_list_length(darktable.develop->form_visible->points) < 2)
dt_masks_change_form_gui(NULL);
else
{
dt_masks_clear_form_gui(darktable.develop);
GList *forms = g_list_first(darktable.develop->form_visible->points);
while(forms)
{
dt_masks_point_group_t *gpt = (dt_masks_point_group_t *)forms->data;
if(gpt->formid == form->formid)
{
darktable.develop->form_visible->points
= g_list_remove(darktable.develop->form_visible->points, gpt);
free(gpt);
break;
}
forms = g_list_next(forms);
}
gui->edit_mode = DT_MASKS_EDIT_FULL;
}
// we remove the shape
dt_dev_masks_list_remove(darktable.develop, form->formid, parentid);
dt_masks_form_remove(module, dt_masks_get_from_id(darktable.develop, parentid), form);
return 1;
}
if(gui->form_dragging)
{
// we get the ellipse
dt_masks_point_ellipse_t *ellipse = (dt_masks_point_ellipse_t *)(g_list_first(form->points)->data);
// we end the form dragging
gui->form_dragging = FALSE;
// we change the center value
float wd = darktable.develop->preview_pipe->backbuf_width;
float ht = darktable.develop->preview_pipe->backbuf_height;
float pts[2] = { pzx * wd + gui->dx, pzy * ht + gui->dy };
dt_dev_distort_backtransform(darktable.develop, pts, 1);
ellipse->center[0] = pts[0] / darktable.develop->preview_pipe->iwidth;
ellipse->center[1] = pts[1] / darktable.develop->preview_pipe->iheight;
dt_masks_write_form(form, darktable.develop);
// we recreate the form points
dt_masks_gui_form_remove(form, gui, index);
dt_masks_gui_form_create(form, gui, index);
// we save the move
dt_masks_update_image(darktable.develop);
return 1;
}
else if(gui->border_toggling)
{
// we get the ellipse
dt_masks_point_ellipse_t *ellipse = (dt_masks_point_ellipse_t *)(g_list_first(form->points)->data);
// we end the border toggling
gui->border_toggling = FALSE;
// toggle feathering type of border and adjust border radius accordingly
if(ellipse->flags & DT_MASKS_ELLIPSE_PROPORTIONAL)
{
const float min_radius = fmin(ellipse->radius[0], ellipse->radius[1]);
ellipse->border = ellipse->border * min_radius;
ellipse->border = CLAMP(ellipse->border, 0.001f, 1.0f);
ellipse->flags &= ~DT_MASKS_ELLIPSE_PROPORTIONAL;
}
else
{
const float min_radius = fmin(ellipse->radius[0], ellipse->radius[1]);
ellipse->border = ellipse->border/min_radius;
ellipse->border = CLAMP(ellipse->border, 0.001f/min_radius, 1.0f/min_radius);
ellipse->flags |= DT_MASKS_ELLIPSE_PROPORTIONAL;
}
if(form->type & DT_MASKS_CLONE)
{
dt_conf_set_int("plugins/darkroom/spots/ellipse_flags", ellipse->flags);
dt_conf_set_float("plugins/darkroom/spots/ellipse_border", ellipse->border);
}
else
{
dt_conf_set_int("plugins/darkroom/masks/ellipse/flags", ellipse->flags);
dt_conf_set_float("plugins/darkroom/masks/ellipse/border", ellipse->border);
}
dt_masks_write_form(form, darktable.develop);
// we recreate the form points
dt_masks_gui_form_remove(form, gui, index);
dt_masks_gui_form_create(form, gui, index);
// we save the new parameters
dt_masks_update_image(darktable.develop);
return 1;
}
else if(gui->form_rotating && gui->edit_mode == DT_MASKS_EDIT_FULL)
{
// we get the ellipse
dt_masks_point_ellipse_t *ellipse = (dt_masks_point_ellipse_t *)(g_list_first(form->points)->data);
// we end the form rotating
gui->form_rotating = FALSE;
float wd = darktable.develop->preview_pipe->backbuf_width;
float ht = darktable.develop->preview_pipe->backbuf_height;
float x = pzx * wd;
float y = pzy * ht;
// we need the reference point
dt_masks_form_gui_points_t *gpt = (dt_masks_form_gui_points_t *)g_list_nth_data(gui->points, index);
if(!gpt) return 0;
float xref = gpt->points[0];
float yref = gpt->points[1];
float dv = atan2(y - yref, x - xref) - atan2(-gui->dy, -gui->dx);
ellipse->rotation += dv / M_PI * 180.0f;
ellipse->rotation = fmodf(ellipse->rotation, 360.0f);
if(form->type & DT_MASKS_CLONE)
dt_conf_set_float("plugins/darkroom/spots/ellipse_rotation", ellipse->rotation);
else
dt_conf_set_float("plugins/darkroom/masks/ellipse/rotation", ellipse->rotation);
dt_masks_write_form(form, darktable.develop);
// we recreate the form points
dt_masks_gui_form_remove(form, gui, index);
dt_masks_gui_form_create(form, gui, index);
// we save the rotation
dt_masks_update_image(darktable.develop);
return 1;
}
else if(gui->point_dragging >= 1 && gui->edit_mode == DT_MASKS_EDIT_FULL)
{
// we get the ellipse
dt_masks_point_ellipse_t *ellipse = (dt_masks_point_ellipse_t *)(g_list_first(form->points)->data);
const int k = gui->point_dragging;
// we end the point dragging
gui->point_dragging = -1;
// we need the reference points
dt_masks_form_gui_points_t *gpt = (dt_masks_form_gui_points_t *)g_list_nth_data(gui->points, index);
if(!gpt) return 0;
const float xref = gpt->points[0];
const float yref = gpt->points[1];
const float rx = gpt->points[k * 2] - xref;
const float ry = gpt->points[k * 2 + 1] - yref;
const float deltax = gui->posx + gui->dx - xref;
const float deltay = gui->posy + gui->dy - yref;
const float r = sqrtf(rx * rx + ry * ry);
const float d = (rx * deltax + ry * deltay) / r;
const float s = fmaxf(r > 0.0f ? (r + d) / r : 0.0f, 0.0f);
// make sure we adjust the right radius: anchor points and 1 and 2 correspond to the ellipse's longer axis
if(((k == 1 || k == 2) && ellipse->radius[0] > ellipse->radius[1])
|| ((k == 3 || k == 4) && ellipse->radius[0] <= ellipse->radius[1]))
{
ellipse->radius[0] = MAX(0.002f, ellipse->radius[0] * s);
if(form->type & DT_MASKS_CLONE)
dt_conf_set_float("plugins/darkroom/spots/ellipse_radius_a", ellipse->radius[0]);
else
dt_conf_set_float("plugins/darkroom/masks/ellipse/radius_a", ellipse->radius[0]);
}
else
{
ellipse->radius[1] = MAX(0.002f, ellipse->radius[1] * s);
if(form->type & DT_MASKS_CLONE)
dt_conf_set_float("plugins/darkroom/spots/ellipse_radius_b", ellipse->radius[1]);
else
dt_conf_set_float("plugins/darkroom/masks/ellipse/radius_b", ellipse->radius[1]);
}
dt_masks_write_form(form, darktable.develop);
// we recreate the form points
dt_masks_gui_form_remove(form, gui, index);
dt_masks_gui_form_create(form, gui, index);
// we save the rotation
dt_masks_update_image(darktable.develop);
return 1;
}
else if(gui->source_dragging)
{
// we end the form dragging
gui->source_dragging = FALSE;
if(gui->scrollx != 0.0 || gui->scrolly != 0.0)
{
dt_masks_point_ellipse_t *ellipse = (dt_masks_point_ellipse_t *)(g_list_first(form->points)->data);
form->source[0] = ellipse->center[0] + ellipse->radius[0];
form->source[1] = ellipse->center[1] - ellipse->radius[1];
gui->scrollx = gui->scrolly = 0.0;
}
else
{
// we change the center value
float wd = darktable.develop->preview_pipe->backbuf_width;
float ht = darktable.develop->preview_pipe->backbuf_height;
float pts[2] = { pzx * wd + gui->dx, pzy * ht + gui->dy };
dt_dev_distort_backtransform(darktable.develop, pts, 1);
form->source[0] = pts[0] / darktable.develop->preview_pipe->iwidth;
form->source[1] = pts[1] / darktable.develop->preview_pipe->iheight;
}
dt_masks_write_form(form, darktable.develop);
// we recreate the form points
dt_masks_gui_form_remove(form, gui, index);
dt_masks_gui_form_create(form, gui, index);
// we save the move
dt_masks_update_image(darktable.develop);
return 1;
}
return 0;
}
static int dt_ellipse_events_mouse_scrolled(struct dt_iop_module_t *module, float pzx, float pzy, int up,
uint32_t state, dt_masks_form_t *form, int parentid,
dt_masks_form_gui_t *gui, int index)
{
if(gui->form_selected)
{
// we register the current position
if(gui->scrollx == 0.0f && gui->scrolly == 0.0f)
{
gui->scrollx = pzx;
gui->scrolly = pzy;
}
if((state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
{
// we try to change the opacity
dt_masks_form_change_opacity(form, parentid, up);
}
else
{
dt_masks_point_ellipse_t *ellipse = (dt_masks_point_ellipse_t *)(g_list_first(form->points)->data);
if(gui->border_selected)
{
const float reference = (ellipse->flags & DT_MASKS_ELLIPSE_PROPORTIONAL ? 1.0f/fmin(ellipse->radius[0], ellipse->radius[1]) : 1.0f);
if(up && ellipse->border > 0.001f * reference)
ellipse->border *= 0.97f;
else if(!up && ellipse->border < 1.0f * reference)
ellipse->border *= 1.0f/0.97f;
else return 1;
ellipse->border = CLAMP(ellipse->border, 0.001f * reference, reference);
dt_masks_write_form(form, darktable.develop);
dt_masks_gui_form_remove(form, gui, index);
dt_masks_gui_form_create(form, gui, index);
if(form->type & DT_MASKS_CLONE)
dt_conf_set_float("plugins/darkroom/spots/ellipse_border", ellipse->border);
else
dt_conf_set_float("plugins/darkroom/masks/ellipse/border", ellipse->border);
}
else if(gui->edit_mode == DT_MASKS_EDIT_FULL)
{
const float oldradius = ellipse->radius[0];
if(up && ellipse->radius[0] > 0.001f)
ellipse->radius[0] *= 0.97f;
else if(!up && ellipse->radius[0] < 1.0f)
ellipse->radius[0] *= 1.0f / 0.97f;
else return 1;
ellipse->radius[0] = CLAMP(ellipse->radius[0], 0.001f, 1.0f);
const float factor = ellipse->radius[0] / oldradius;
ellipse->radius[1] *= factor;
dt_masks_write_form(form, darktable.develop);
dt_masks_gui_form_remove(form, gui, index);
dt_masks_gui_form_create(form, gui, index);
if(form->type & DT_MASKS_CLONE)
{
dt_conf_set_float("plugins/darkroom/spots/ellipse_radius_a", ellipse->radius[0]);
dt_conf_set_float("plugins/darkroom/spots/ellipse_radius_b", ellipse->radius[1]);
}
else
{
dt_conf_set_float("plugins/darkroom/masks/ellipse/radius_a", ellipse->radius[0]);
dt_conf_set_float("plugins/darkroom/masks/ellipse/radius_b", ellipse->radius[1]);
}
}
else
{
return 0;
}
dt_masks_update_image(darktable.develop);
}
return 1;
}
return 0;
}
static int dt_circle_events_mouse_scrolled(struct dt_iop_module_t *module, float pzx, float pzy, int up,
uint32_t state, dt_masks_form_t *form, int parentid,
dt_masks_form_gui_t *gui, int index)
{
// add a preview when creating a circle
if(gui->creation)
{
if((state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK)
{
float masks_border;
if(form->type & (DT_MASKS_CLONE | DT_MASKS_NON_CLONE))
masks_border = dt_conf_get_float("plugins/darkroom/spots/circle_border");
else
masks_border = dt_conf_get_float("plugins/darkroom/masks/circle/border");
if(up && masks_border > 0.0005f)
masks_border *= 0.97f;
else if(!up && masks_border < 1.0f)
masks_border *= 1.0f / 0.97f;
if(form->type & (DT_MASKS_CLONE | DT_MASKS_NON_CLONE))
dt_conf_set_float("plugins/darkroom/spots/circle_border", masks_border);
else
dt_conf_set_float("plugins/darkroom/masks/circle/border", masks_border);
}
else if(state == 0)
{
float masks_size;
if(form->type & (DT_MASKS_CLONE | DT_MASKS_NON_CLONE))
masks_size = dt_conf_get_float("plugins/darkroom/spots/circle_size");
else
masks_size = dt_conf_get_float("plugins/darkroom/masks/circle/size");
if(up && masks_size > 0.001f)
masks_size *= 0.97f;
else if(!up && masks_size < 1.0f)
masks_size *= 1.0f / 0.97f;
if(form->type & (DT_MASKS_CLONE | DT_MASKS_NON_CLONE))
dt_conf_set_float("plugins/darkroom/spots/circle_size", masks_size);
else
dt_conf_set_float("plugins/darkroom/masks/circle/size", masks_size);
}
return 1;
}
if(gui->form_selected)
{
// we register the current position
if(gui->scrollx == 0.0f && gui->scrolly == 0.0f)
{
gui->scrollx = pzx;
gui->scrolly = pzy;
}
if((state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
{
// we try to change the opacity
dt_masks_form_change_opacity(form, parentid, up);
}
else
{
dt_masks_point_circle_t *circle = (dt_masks_point_circle_t *)(g_list_first(form->points)->data);
// resize don't care where the mouse is inside a shape
if((state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK)
{
if(up && circle->border > 0.0005f)
circle->border *= 0.97f;
else if(!up && circle->border < 1.0f)
circle->border *= 1.0f / 0.97f;
else
return 1;
dt_masks_write_form(form, darktable.develop);
dt_masks_gui_form_remove(form, gui, index);
dt_masks_gui_form_create(form, gui, index);
if(form->type & (DT_MASKS_CLONE|DT_MASKS_NON_CLONE))
dt_conf_set_float("plugins/darkroom/spots/circle_border", circle->border);
else
dt_conf_set_float("plugins/darkroom/masks/circle/border", circle->border);
}
else if(gui->edit_mode == DT_MASKS_EDIT_FULL)
{
if(up && circle->radius > 0.001f)
circle->radius *= 0.97f;
else if(!up && circle->radius < 1.0f)
circle->radius *= 1.0f / 0.97f;
else
return 1;
dt_masks_write_form(form, darktable.develop);
dt_masks_gui_form_remove(form, gui, index);
dt_masks_gui_form_create(form, gui, index);
if(form->type & (DT_MASKS_CLONE|DT_MASKS_NON_CLONE))
dt_conf_set_float("plugins/darkroom/spots/circle_size", circle->radius);
else
dt_conf_set_float("plugins/darkroom/masks/circle/size", circle->radius);
}
else
{
return 0;
}
dt_masks_update_image(darktable.develop);
}
return 1;
}
return 0;
}
