static gboolean fullscreen_key_accel_callback(GtkAccelGroup *accel_group,
GObject *acceleratable, guint keyval,
GdkModifierType modifier,
gpointer data)
{
GtkWidget *widget;
int fullscreen;
if(data)
{
widget = dt_ui_main_window(darktable.gui->ui);
fullscreen = dt_conf_get_bool("ui_last/fullscreen");
if(fullscreen) gtk_window_unfullscreen(GTK_WINDOW(widget));
else gtk_window_fullscreen (GTK_WINDOW(widget));
fullscreen ^= 1;
dt_conf_set_bool("ui_last/fullscreen", fullscreen);
dt_dev_invalidate(darktable.develop);
}
else
{
widget = dt_ui_main_window(darktable.gui->ui);
gtk_window_unfullscreen(GTK_WINDOW(widget));
fullscreen = 0;
dt_conf_set_bool("ui_last/fullscreen", fullscreen);
dt_dev_invalidate(darktable.develop);
}
/* redraw center view */
gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui));
return TRUE;
}
void _lib_navigation_set_position(dt_lib_module_t *self, double x, double y, int wd, int ht)
{
dt_lib_navigation_t *d = ( dt_lib_navigation_t *)self->data;
dt_dev_zoom_t zoom;
int closeup;
float zoom_x, zoom_y;
DT_CTL_GET_GLOBAL(zoom, dev_zoom);
DT_CTL_GET_GLOBAL(closeup, dev_closeup);
DT_CTL_GET_GLOBAL(zoom_x, dev_zoom_x);
DT_CTL_GET_GLOBAL(zoom_y, dev_zoom_y);
if(d->dragging && zoom != DT_ZOOM_FIT)
{
const int inset = DT_NAVIGATION_INSET;
const float width = wd - 2*inset, height = ht - 2*inset;
const dt_develop_t *dev = darktable.develop;
int iwd, iht;
dt_dev_get_processed_size(dev, &iwd, &iht);
zoom_x = fmaxf(-.5, fminf(((x-inset)/width - .5f)/(iwd*fminf(wd/(float)iwd, ht/(float)iht)/(float)wd), .5));
zoom_y = fmaxf(-.5, fminf(((y-inset)/height - .5f)/(iht*fminf(wd/(float)iwd, ht/(float)iht)/(float)ht), .5));
dt_dev_check_zoom_bounds(darktable.develop, &zoom_x, &zoom_y, zoom, closeup, NULL, NULL);
DT_CTL_SET_GLOBAL(dev_zoom_x, zoom_x);
DT_CTL_SET_GLOBAL(dev_zoom_y, zoom_y);
/* redraw myself */
gtk_widget_queue_draw(self->widget);
/* redraw pipe */
dt_dev_invalidate(darktable.develop);
dt_control_queue_redraw_center();
}
}
void border_scrolled(dt_view_t *view, double x, double y, int which, int up)
{
dt_develop_t *dev = (dt_develop_t *)view->data;
dt_dev_zoom_t zoom;
int closeup;
float zoom_x, zoom_y;
DT_CTL_GET_GLOBAL(zoom, dev_zoom);
DT_CTL_GET_GLOBAL(closeup, dev_closeup);
DT_CTL_GET_GLOBAL(zoom_x, dev_zoom_x);
DT_CTL_GET_GLOBAL(zoom_y, dev_zoom_y);
if(which > 1)
{
if(up) zoom_x -= 0.02;
else zoom_x += 0.02;
}
else
{
if(up) zoom_y -= 0.02;
else zoom_y += 0.02;
}
dt_dev_check_zoom_bounds(dev, &zoom_x, &zoom_y, zoom, closeup, NULL, NULL);
DT_CTL_SET_GLOBAL(dev_zoom_x, zoom_x);
DT_CTL_SET_GLOBAL(dev_zoom_y, zoom_y);
dt_dev_invalidate(dev);
dt_control_queue_redraw();
}
void scrolled(dt_view_t *self, double x, double y, int up, int state)
{
const int32_t capwd = darktable.thumbnail_width;
const int32_t capht = darktable.thumbnail_height;
dt_develop_t *dev = (dt_develop_t *)self->data;
const int32_t width_i = self->width;
const int32_t height_i = self->height;
if(width_i > capwd) x += (capwd-width_i) *.5f;
if(height_i > capht) y += (capht-height_i)*.5f;
int handled = 0;
if(dev->gui_module && dev->gui_module->scrolled) handled = dev->gui_module->scrolled(dev->gui_module, x, y, up, state);
if(handled) return;
// free zoom
dt_dev_zoom_t zoom;
int closeup, procw, proch;
float zoom_x, zoom_y;
DT_CTL_GET_GLOBAL(zoom, dev_zoom);
DT_CTL_GET_GLOBAL(closeup, dev_closeup);
DT_CTL_GET_GLOBAL(zoom_x, dev_zoom_x);
DT_CTL_GET_GLOBAL(zoom_y, dev_zoom_y);
dt_dev_get_processed_size(dev, &procw, &proch);
float scale = dt_dev_get_zoom_scale(dev, zoom, closeup ? 2.0 : 1.0, 0);
const float minscale = dt_dev_get_zoom_scale(dev, DT_ZOOM_FIT, 1.0, 0);
// offset from center now (current zoom_{x,y} points there)
float mouse_off_x = x - .5*dev->width, mouse_off_y = y - .5*dev->height;
zoom_x += mouse_off_x/(procw*scale);
zoom_y += mouse_off_y/(proch*scale);
zoom = DT_ZOOM_FREE;
closeup = 0;
if(up)
{
if (scale == 1.0f) return;
else scale += .1f*(1.0f - minscale);
}
else
{
if (scale == minscale) return;
else scale -= .1f*(1.0f - minscale);
}
DT_CTL_SET_GLOBAL(dev_zoom_scale, scale);
if(scale > 0.99) zoom = DT_ZOOM_1;
if(scale < minscale + 0.01) zoom = DT_ZOOM_FIT;
if(zoom != DT_ZOOM_1)
{
zoom_x -= mouse_off_x/(procw*scale);
zoom_y -= mouse_off_y/(proch*scale);
}
dt_dev_check_zoom_bounds(dev, &zoom_x, &zoom_y, zoom, closeup, NULL, NULL);
DT_CTL_SET_GLOBAL(dev_zoom, zoom);
DT_CTL_SET_GLOBAL(dev_closeup, closeup);
if(zoom != DT_ZOOM_1)
{
DT_CTL_SET_GLOBAL(dev_zoom_x, zoom_x);
DT_CTL_SET_GLOBAL(dev_zoom_y, zoom_y);
}
dt_dev_invalidate(dev);
dt_control_queue_redraw();
}
void dt_dev_reload_image(dt_develop_t *dev, const uint32_t imgid)
{
const dt_image_t *image = dt_image_cache_read_get(darktable.image_cache, imgid);
dev->image_storage = *image;
dt_image_cache_read_release(darktable.image_cache, image);
dev->image_force_reload = dev->image_loading = dev->preview_loading = 1;
dev->pipe->changed |= DT_DEV_PIPE_SYNCH;
dt_dev_invalidate(dev); // only invalidate image, preview will follow once it's loaded.
}
static void _lib_duplicate_thumb_press_callback(GtkWidget *widget, GdkEventButton *event, dt_lib_module_t *self)
{
dt_lib_duplicate_t *d = (dt_lib_duplicate_t *)self->data;
int imgid = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget),"imgid"));
if(event->button == 1)
{
if(event->type == GDK_BUTTON_PRESS)
{
dt_develop_t *dev = darktable.develop;
if(!dev) return;
dt_dev_zoom_t zoom;
int closeup;
float zoom_x, zoom_y;
closeup = dt_control_get_dev_closeup();
float scale = 0;
zoom = DT_ZOOM_FIT;
scale = dt_dev_get_zoom_scale(dev, DT_ZOOM_FIT, 1.0, 0);
dt_dev_check_zoom_bounds(dev, &zoom_x, &zoom_y, zoom, closeup, NULL, NULL);
dt_control_set_dev_zoom_scale(scale);
dt_control_set_dev_zoom(zoom);
dt_control_set_dev_closeup(closeup);
dt_control_set_dev_zoom_x(zoom_x);
dt_control_set_dev_zoom_y(zoom_y);
dt_dev_invalidate(dev);
dt_control_queue_redraw();
dt_dev_invalidate(darktable.develop);
d->imgid = imgid;
dt_control_queue_redraw_center();
}
else if(event->type == GDK_2BUTTON_PRESS)
{
// to select the duplicate, we reuse the filmstrip proxy
_do_select(imgid);
}
}
}
void dt_dev_configure (dt_develop_t *dev, int wd, int ht)
{
wd = MIN(darktable.thumbnail_width, wd);
ht = MIN(darktable.thumbnail_height, ht);
if(dev->width != wd || dev->height != ht)
{
dev->width = wd;
dev->height = ht;
dev->preview_pipe->changed |= DT_DEV_PIPE_ZOOMED;
dev->pipe->changed |= DT_DEV_PIPE_ZOOMED;
dt_dev_invalidate(dev);
}
}
static gboolean
zoom_key_accel(GtkAccelGroup *accel_group,
GObject *acceleratable, guint keyval,
GdkModifierType modifier, gpointer data)
{
dt_develop_t *dev = darktable.develop;
int zoom, closeup;
float zoom_x, zoom_y;
switch ((long int)data)
{
case 1:
DT_CTL_GET_GLOBAL(zoom, dev_zoom);
DT_CTL_GET_GLOBAL(closeup, dev_closeup);
if(zoom == DT_ZOOM_1) closeup ^= 1;
DT_CTL_SET_GLOBAL(dev_closeup, closeup);
DT_CTL_SET_GLOBAL(dev_zoom, DT_ZOOM_1);
dt_dev_invalidate(dev);
break;
case 2:
DT_CTL_SET_GLOBAL(dev_zoom, DT_ZOOM_FILL);
dt_dev_check_zoom_bounds(dev, &zoom_x, &zoom_y, DT_ZOOM_FILL, 0, NULL, NULL);
DT_CTL_SET_GLOBAL(dev_zoom_x, zoom_x);
DT_CTL_SET_GLOBAL(dev_zoom_y, zoom_y);
DT_CTL_SET_GLOBAL(dev_closeup, 0);
dt_dev_invalidate(dev);
break;
case 3:
DT_CTL_SET_GLOBAL(dev_zoom, DT_ZOOM_FIT);
DT_CTL_SET_GLOBAL(dev_zoom_x, 0);
DT_CTL_SET_GLOBAL(dev_zoom_y, 0);
DT_CTL_SET_GLOBAL(dev_closeup, 0);
dt_dev_invalidate(dev);
break;
default:
break;
}
dt_control_queue_redraw_center();
return TRUE;
}
static void _zoom_preset_change(int val)
{
// dt_lib_module_t *self = (dt_lib_module_t *)user_data;
dt_develop_t *dev = darktable.develop;
if(!dev) return;
dt_dev_zoom_t zoom;
int closeup, procw, proch;
float zoom_x, zoom_y;
zoom = dt_control_get_dev_zoom();
closeup = dt_control_get_dev_closeup();
zoom_x = dt_control_get_dev_zoom_x();
zoom_y = dt_control_get_dev_zoom_y();
dt_dev_get_processed_size(dev, &procw, &proch);
float scale = 0;
zoom_x = 0.0f; //+= (1.0/scale)*(x - .5f*dev->width )/procw;
zoom_y = 0.0f; //+= (1.0/scale)*(y - .5f*dev->height)/proch;
if(val == 0)
{
scale = 0.5 * dt_dev_get_zoom_scale(dev, DT_ZOOM_FIT, 1.0, 0);
zoom = DT_ZOOM_FREE;
}
else if(val == 1)
{
zoom = DT_ZOOM_FIT;
scale = dt_dev_get_zoom_scale(dev, DT_ZOOM_FIT, 1.0, 0);
}
else if(val == 2)
{
scale = dt_dev_get_zoom_scale(dev, DT_ZOOM_1, 1.0, 0);
zoom = DT_ZOOM_1;
}
else if(val == 3)
{
scale = 2.0f;
zoom = DT_ZOOM_FREE;
}
dt_dev_check_zoom_bounds(dev, &zoom_x, &zoom_y, zoom, closeup, NULL, NULL);
dt_control_set_dev_zoom_scale(scale);
dt_control_set_dev_zoom(zoom);
dt_control_set_dev_closeup(closeup);
dt_control_set_dev_zoom_x(zoom_x);
dt_control_set_dev_zoom_y(zoom_y);
dt_dev_invalidate(dev);
dt_control_queue_redraw();
}
static void _lib_snapshots_toggled_callback(GtkToggleButton *widget, gpointer user_data)
{
dt_lib_module_t *self = (dt_lib_module_t*)user_data;
dt_lib_snapshots_t *d = (dt_lib_snapshots_t *)self->data;
/* get current snapshot index */
int which = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget),"snapshot"));
/* free current snapshot image if exists */
if (d->snapshot_image)
{
cairo_surface_destroy(d->snapshot_image);
d->snapshot_image = NULL;
}
/* check if snapshot is activated */
if (gtk_toggle_button_get_active(widget))
{
/* lets inactivate all togglebuttons except for self */
for(uint32_t k=0; k<d->size; k++)
if(GTK_WIDGET(widget) != d->snapshot[k].button)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d->snapshot[k].button), FALSE);
/* setup snapshot */
d->selected = which;
dt_lib_snapshot_t *s = d->snapshot + (which-1);
dt_control_set_dev_zoom_y(s->zoom_y);
dt_control_set_dev_zoom_x(s->zoom_x);
dt_control_set_dev_zoom(s->zoom);
dt_control_set_dev_closeup(s->closeup);
dt_control_set_dev_zoom_scale(s->zoom_scale);
dt_dev_invalidate(darktable.develop);
d->snapshot_image = cairo_image_surface_create_from_png(s->filename);
}
/* redraw center view */
dt_control_queue_redraw_center();
}
int dt_control_key_pressed_override(guint key, guint state)
{
dt_control_accels_t *accels = &darktable.control->accels;
// TODO: if darkroom mode
// did a : vim-style command start?
static GList *autocomplete = NULL;
static char vimkey_input[256];
if(darktable.control->vimkey_cnt)
{
guchar unichar = gdk_keyval_to_unicode(key);
if(key == GDK_KEY_Return)
{
if(!strcmp(darktable.control->vimkey, ":q"))
{
dt_control_quit();
}
else
{
dt_bauhaus_vimkey_exec(darktable.control->vimkey);
}
darktable.control->vimkey[0] = 0;
darktable.control->vimkey_cnt = 0;
dt_control_log_ack_all();
g_list_free(autocomplete);
autocomplete = NULL;
}
else if(key == GDK_KEY_Escape)
{
darktable.control->vimkey[0] = 0;
darktable.control->vimkey_cnt = 0;
dt_control_log_ack_all();
g_list_free(autocomplete);
autocomplete = NULL;
}
else if(key == GDK_KEY_BackSpace)
{
darktable.control->vimkey_cnt
-= (darktable.control->vimkey + darktable.control->vimkey_cnt)
- g_utf8_prev_char(darktable.control->vimkey + darktable.control->vimkey_cnt);
darktable.control->vimkey[darktable.control->vimkey_cnt] = 0;
if(darktable.control->vimkey_cnt == 0)
dt_control_log_ack_all();
else
dt_control_log("%s", darktable.control->vimkey);
g_list_free(autocomplete);
autocomplete = NULL;
}
else if(key == GDK_KEY_Tab)
{
// TODO: also support :preset and :get?
// auto complete:
if(darktable.control->vimkey_cnt < 5)
{
snprintf(darktable.control->vimkey, sizeof(darktable.control->vimkey), ":set ");
darktable.control->vimkey_cnt = 5;
}
else if(!autocomplete)
{
// TODO: handle '.'-separated things separately
// this is a static list, and tab cycles through the list
g_strlcpy(vimkey_input, darktable.control->vimkey + 5, sizeof(vimkey_input));
autocomplete = dt_bauhaus_vimkey_complete(darktable.control->vimkey + 5);
autocomplete = g_list_append(autocomplete, vimkey_input); // remember input to cycle back
}
if(autocomplete)
{
// pop first.
// the paths themselves are owned by bauhaus,
// no free required.
snprintf(darktable.control->vimkey, sizeof(darktable.control->vimkey), ":set %s",
(char *)autocomplete->data);
autocomplete = g_list_remove(autocomplete, autocomplete->data);
darktable.control->vimkey_cnt = strlen(darktable.control->vimkey);
}
dt_control_log("%s", darktable.control->vimkey);
}
else if(g_unichar_isprint(unichar)) // printable unicode character
{
gchar utf8[6];
gint char_width = g_unichar_to_utf8(unichar, utf8);
if(darktable.control->vimkey_cnt + 1 + char_width < 256)
{
g_utf8_strncpy(darktable.control->vimkey + darktable.control->vimkey_cnt, utf8, 1);
darktable.control->vimkey_cnt += char_width;
darktable.control->vimkey[darktable.control->vimkey_cnt] = 0;
dt_control_log("%s", darktable.control->vimkey);
g_list_free(autocomplete);
autocomplete = NULL;
}
}
else if(key == GDK_KEY_Up)
{
// TODO: step history up and copy to vimkey
}
else if(key == GDK_KEY_Down)
{
// TODO: step history down and copy to vimkey
}
return 1;
}
else if(key == ':' && darktable.control->key_accelerators_on)
{
darktable.control->vimkey[0] = ':';
darktable.control->vimkey[1] = 0;
darktable.control->vimkey_cnt = 1;
dt_control_log("%s", darktable.control->vimkey);
return 1;
}
/* check if key accelerators are enabled*/
if(darktable.control->key_accelerators_on != 1) return 0;
if(key == accels->global_sideborders.accel_key && state == accels->global_sideborders.accel_mods)
{
/* toggle panel viewstate */
dt_ui_toggle_panels_visibility(darktable.gui->ui);
/* trigger invalidation of centerview to reprocess pipe */
dt_dev_invalidate(darktable.develop);
gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui));
return 1;
}
else if(key == accels->global_header.accel_key && state == accels->global_header.accel_mods)
{
char key[512];
const dt_view_t *cv = dt_view_manager_get_current_view(darktable.view_manager);
/* do nothing if in collapse panel state
TODO: reconsider adding this check to ui api */
g_snprintf(key, sizeof(key), "%s/ui/panel_collaps_state", cv->module_name);
if(dt_conf_get_int(key)) return 0;
/* toggle the header visibility state */
g_snprintf(key, sizeof(key), "%s/ui/show_header", cv->module_name);
gboolean header = !dt_conf_get_bool(key);
dt_conf_set_bool(key, header);
/* show/hide the actual header panel */
dt_ui_panel_show(darktable.gui->ui, DT_UI_PANEL_TOP, header, TRUE);
gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui));
return 1;
}
return 0;
}
int button_pressed(dt_view_t *self, double x, double y, int which, int type, uint32_t state)
{
const int32_t capwd = darktable.thumbnail_width;
const int32_t capht = darktable.thumbnail_height;
dt_develop_t *dev = (dt_develop_t *)self->data;
const int32_t width_i = self->width;
const int32_t height_i = self->height;
if(width_i > capwd) x += (capwd-width_i) *.5f;
if(height_i > capht) y += (capht-height_i)*.5f;
int handled = 0;
if(dev->gui_module && dev->gui_module->request_color_pick && which == 1)
{
float zoom_x, zoom_y;
dt_dev_get_pointer_zoom_pos(dev, x, y, &zoom_x, &zoom_y);
if(darktable.lib->proxy.colorpicker.size)
{
dev->gui_module->color_picker_box[0] = .5f+zoom_x;
dev->gui_module->color_picker_box[1] = .5f+zoom_y;
dev->gui_module->color_picker_box[2] = .5f+zoom_x;
dev->gui_module->color_picker_box[3] = .5f+zoom_y;
}
else
{
dev->gui_module->color_picker_point[0] = .5f+zoom_x;
dev->gui_module->color_picker_point[1] = .5f+zoom_y;
dev->preview_pipe->changed |= DT_DEV_PIPE_SYNCH;
dt_dev_invalidate_all(dev);
}
dt_control_queue_redraw();
return 1;
}
if(dev->gui_module && dev->gui_module->button_pressed) handled = dev->gui_module->button_pressed(dev->gui_module, x, y, which, type, state);
if(handled) return handled;
if(which == 1 && type == GDK_2BUTTON_PRESS) return 0;
if(which == 1)
{
dt_control_change_cursor(GDK_HAND1);
return 1;
}
if(which == 2)
{
// zoom to 1:1 2:1 and back
dt_dev_zoom_t zoom;
int closeup, procw, proch;
float zoom_x, zoom_y;
DT_CTL_GET_GLOBAL(zoom, dev_zoom);
DT_CTL_GET_GLOBAL(closeup, dev_closeup);
DT_CTL_GET_GLOBAL(zoom_x, dev_zoom_x);
DT_CTL_GET_GLOBAL(zoom_y, dev_zoom_y);
dt_dev_get_processed_size(dev, &procw, &proch);
const float scale = dt_dev_get_zoom_scale(dev, zoom, closeup ? 2 : 1, 0);
zoom_x += (1.0/scale)*(x - .5f*dev->width )/procw;
zoom_y += (1.0/scale)*(y - .5f*dev->height)/proch;
if(zoom == DT_ZOOM_1)
{
if(!closeup) closeup = 1;
else
{
zoom = DT_ZOOM_FIT;
zoom_x = zoom_y = 0.0f;
closeup = 0;
}
}
else zoom = DT_ZOOM_1;
dt_dev_check_zoom_bounds(dev, &zoom_x, &zoom_y, zoom, closeup, NULL, NULL);
DT_CTL_SET_GLOBAL(dev_zoom, zoom);
DT_CTL_SET_GLOBAL(dev_closeup, closeup);
DT_CTL_SET_GLOBAL(dev_zoom_x, zoom_x);
DT_CTL_SET_GLOBAL(dev_zoom_y, zoom_y);
dt_dev_invalidate(dev);
return 1;
}
return 0;
}
void mouse_moved(dt_view_t *self, double x, double y, int which)
{
const int32_t capwd = darktable.thumbnail_width;
const int32_t capht = darktable.thumbnail_height;
dt_develop_t *dev = (dt_develop_t *)self->data;
// if we are not hovering over a thumbnail in the filmstrip -> show metadata of opened image.
int32_t mouse_over_id = -1;
DT_CTL_GET_GLOBAL(mouse_over_id, lib_image_mouse_over_id);
if(mouse_over_id == -1)
{
mouse_over_id = dev->image_storage.id;
DT_CTL_SET_GLOBAL(lib_image_mouse_over_id, mouse_over_id);
}
dt_control_t *ctl = darktable.control;
const int32_t width_i = self->width;
const int32_t height_i = self->height;
int32_t offx = 0.0f, offy = 0.0f;
if(width_i > capwd) offx = (capwd-width_i) *.5f;
if(height_i > capht) offy = (capht-height_i)*.5f;
int handled = 0;
x += offx;
y += offy;
if(dev->gui_module && dev->gui_module->request_color_pick &&
ctl->button_down &&
ctl->button_down_which == 1)
{
// module requested a color box
float zoom_x, zoom_y, bzoom_x, bzoom_y;
dt_dev_get_pointer_zoom_pos(dev, x, y, &zoom_x, &zoom_y);
dt_dev_get_pointer_zoom_pos(dev, ctl->button_x + offx, ctl->button_y + offy, &bzoom_x, &bzoom_y);
if(darktable.lib->proxy.colorpicker.size)
{
dev->gui_module->color_picker_box[0] = fmaxf(0.0, fminf(.5f+bzoom_x, .5f+zoom_x));
dev->gui_module->color_picker_box[1] = fmaxf(0.0, fminf(.5f+bzoom_y, .5f+zoom_y));
dev->gui_module->color_picker_box[2] = fminf(1.0, fmaxf(.5f+bzoom_x, .5f+zoom_x));
dev->gui_module->color_picker_box[3] = fminf(1.0, fmaxf(.5f+bzoom_y, .5f+zoom_y));
}
else
{
dev->gui_module->color_picker_point[0] = .5f + zoom_x;
dev->gui_module->color_picker_point[1] = .5f + zoom_y;
}
dev->preview_pipe->changed |= DT_DEV_PIPE_SYNCH;
dt_dev_invalidate_all(dev);
dt_control_queue_redraw();
return;
}
if(dev->gui_module && dev->gui_module->mouse_moved) handled = dev->gui_module->mouse_moved(dev->gui_module, x, y, which);
if(handled) return;
if(darktable.control->button_down && darktable.control->button_down_which == 1)
{
// depending on dev_zoom, adjust dev_zoom_x/y.
dt_dev_zoom_t zoom;
int closeup;
DT_CTL_GET_GLOBAL(zoom, dev_zoom);
DT_CTL_GET_GLOBAL(closeup, dev_closeup);
int procw, proch;
dt_dev_get_processed_size(dev, &procw, &proch);
const float scale = dt_dev_get_zoom_scale(dev, zoom, closeup ? 2 : 1, 0);
float old_zoom_x, old_zoom_y;
DT_CTL_GET_GLOBAL(old_zoom_x, dev_zoom_x);
DT_CTL_GET_GLOBAL(old_zoom_y, dev_zoom_y);
float zx = old_zoom_x - (1.0/scale)*(x - ctl->button_x - offx)/procw;
float zy = old_zoom_y - (1.0/scale)*(y - ctl->button_y - offy)/proch;
dt_dev_check_zoom_bounds(dev, &zx, &zy, zoom, closeup, NULL, NULL);
DT_CTL_SET_GLOBAL(dev_zoom_x, zx);
DT_CTL_SET_GLOBAL(dev_zoom_y, zy);
ctl->button_x = x - offx;
ctl->button_y = y - offy;
dt_dev_invalidate(dev);
dt_control_queue_redraw();
}
}
