/**
* gimp_zoom_model_zoom:
* @model: a #GimpZoomModel
* @zoom_type: the #GimpZoomType
* @scale: ignored unless @zoom_type == %GIMP_ZOOM_TO
*
* Since GIMP 2.4
**/
void
gimp_zoom_model_zoom (GimpZoomModel *model,
GimpZoomType zoom_type,
gdouble scale)
{
g_return_if_fail (GIMP_IS_ZOOM_MODEL (model));
if (zoom_type != GIMP_ZOOM_TO)
scale = gimp_zoom_model_get_factor (model);
g_object_set (model,
"value", gimp_zoom_model_zoom_step (zoom_type, scale),
NULL);
}
void
gimp_display_shell_set_initial_scale (GimpDisplayShell *shell,
gdouble scale,
gint *display_width,
gint *display_height)
{
GimpImage *image;
GdkScreen *screen;
gint image_width;
gint image_height;
gint shell_width;
gint shell_height;
gint screen_width;
gint screen_height;
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
image = gimp_display_get_image (shell->display);
screen = gtk_widget_get_screen (GTK_WIDGET (shell));
image_width = gimp_image_get_width (image);
image_height = gimp_image_get_height (image);
screen_width = gdk_screen_get_width (screen) * 0.75;
screen_height = gdk_screen_get_height (screen) * 0.75;
/* We need to zoom before we use SCALE[XY] */
gimp_zoom_model_zoom (shell->zoom, GIMP_ZOOM_TO, scale);
shell_width = SCALEX (shell, image_width);
shell_height = SCALEY (shell, image_height);
if (shell->display->config->initial_zoom_to_fit)
{
/* Limit to the size of the screen... */
if (shell_width > screen_width || shell_height > screen_height)
{
gdouble new_scale;
gdouble current = gimp_zoom_model_get_factor (shell->zoom);
new_scale = current * MIN (((gdouble) screen_height) / shell_height,
((gdouble) screen_width) / shell_width);
new_scale = gimp_zoom_model_zoom_step (GIMP_ZOOM_OUT, new_scale);
/* Since zooming out might skip a zoom step we zoom in
* again and test if we are small enough.
*/
gimp_zoom_model_zoom (shell->zoom, GIMP_ZOOM_TO,
gimp_zoom_model_zoom_step (GIMP_ZOOM_IN,
new_scale));
if (SCALEX (shell, image_width) > screen_width ||
SCALEY (shell, image_height) > screen_height)
gimp_zoom_model_zoom (shell->zoom, GIMP_ZOOM_TO, new_scale);
shell_width = SCALEX (shell, image_width);
shell_height = SCALEY (shell, image_height);
}
}
else
{
/* Set up size like above, but do not zoom to fit. Useful when
* working on large images.
*/
if (shell_width > screen_width)
shell_width = screen_width;
if (shell_height > screen_height)
shell_height = screen_height;
}
if (display_width)
*display_width = shell_width;
if (display_height)
*display_height = shell_height;
}
/**
* gimp_display_shell_scale:
* @shell: the #GimpDisplayShell
* @zoom_type: whether to zoom in, our or to a specific scale
* @scale: ignored unless @zoom_type == %GIMP_ZOOM_TO
*
* This function figures out the context of the zoom and behaves
* appropriatley thereafter.
*
**/
void
gimp_display_shell_scale (GimpDisplayShell *shell,
GimpZoomType zoom_type,
gdouble new_scale,
GimpZoomFocus zoom_focus)
{
gdouble current_scale;
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
g_return_if_fail (shell->canvas != NULL);
current_scale = gimp_zoom_model_get_factor (shell->zoom);
if (zoom_type != GIMP_ZOOM_TO)
new_scale = gimp_zoom_model_zoom_step (zoom_type, current_scale);
if (! SCALE_EQUALS (new_scale, current_scale))
{
GimpDisplayConfig *config = shell->display->config;
gboolean resize_window;
/* Resize windows only in multi-window mode */
resize_window = (config->resize_windows_on_zoom &&
! GIMP_GUI_CONFIG (config)->single_window_mode);
if (resize_window)
{
/* If the window is resized on zoom, simply do the zoom and
* get things rolling
*/
gimp_zoom_model_zoom (shell->zoom, GIMP_ZOOM_TO, new_scale);
gimp_display_shell_scale_resize (shell, TRUE, FALSE);
}
else
{
gboolean starts_fitting_horiz;
gboolean starts_fitting_vert;
gboolean zoom_focus_almost_centered_horiz;
gboolean zoom_focus_almost_centered_vert;
gboolean image_center_almost_centered_horiz;
gboolean image_center_almost_centered_vert;
gdouble x, y;
gint image_center_x;
gint image_center_y;
gimp_display_shell_scale_get_zoom_focus (shell,
new_scale,
current_scale,
&x,
&y,
zoom_focus);
gimp_display_shell_scale_get_image_center_viewport (shell,
&image_center_x,
&image_center_y);
gimp_display_shell_scale_to (shell, new_scale, x, y);
/* If an image axis started to fit due to zooming out or if
* the focus point is as good as in the center, center on
* that axis
*/
gimp_display_shell_scale_image_starts_to_fit (shell,
new_scale,
current_scale,
&starts_fitting_horiz,
&starts_fitting_vert);
gimp_display_shell_scale_viewport_coord_almost_centered (shell,
x,
y,
&zoom_focus_almost_centered_horiz,
&zoom_focus_almost_centered_vert);
gimp_display_shell_scale_viewport_coord_almost_centered (shell,
image_center_x,
image_center_y,
&image_center_almost_centered_horiz,
&image_center_almost_centered_vert);
gimp_display_shell_scroll_center_image (shell,
starts_fitting_horiz ||
(zoom_focus_almost_centered_horiz &&
image_center_almost_centered_horiz),
starts_fitting_vert ||
(zoom_focus_almost_centered_vert &&
image_center_almost_centered_vert));
}
}
}
void
gimp_display_shell_set_initial_scale (GimpDisplayShell *shell,
gdouble scale,
gint *display_width,
gint *display_height)
{
GimpImage *image;
GdkRectangle workarea;
gint image_width;
gint image_height;
gint monitor_width;
gint monitor_height;
gint shell_width;
gint shell_height;
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
image = gimp_display_get_image (shell->display);
gdk_monitor_get_workarea (shell->initial_monitor, &workarea);
image_width = gimp_image_get_width (image);
image_height = gimp_image_get_height (image);
monitor_width = workarea.width * 0.75;
monitor_height = workarea.height * 0.75;
/* We need to zoom before we use SCALE[XY] */
gimp_zoom_model_zoom (shell->zoom, GIMP_ZOOM_TO, scale);
shell_width = SCALEX (shell, image_width);
shell_height = SCALEY (shell, image_height);
if (shell->display->config->initial_zoom_to_fit)
{
/* Limit to the size of the monitor... */
if (shell_width > monitor_width || shell_height > monitor_height)
{
gdouble new_scale;
gdouble current = gimp_zoom_model_get_factor (shell->zoom);
new_scale = current * MIN (((gdouble) monitor_height) / shell_height,
((gdouble) monitor_width) / shell_width);
new_scale = gimp_zoom_model_zoom_step (GIMP_ZOOM_OUT, new_scale, 0.0);
/* Since zooming out might skip a zoom step we zoom in
* again and test if we are small enough.
*/
gimp_zoom_model_zoom (shell->zoom, GIMP_ZOOM_TO,
gimp_zoom_model_zoom_step (GIMP_ZOOM_IN,
new_scale, 0.0));
if (SCALEX (shell, image_width) > monitor_width ||
SCALEY (shell, image_height) > monitor_height)
gimp_zoom_model_zoom (shell->zoom, GIMP_ZOOM_TO, new_scale);
shell_width = SCALEX (shell, image_width);
shell_height = SCALEY (shell, image_height);
}
}
else
{
/* Set up size like above, but do not zoom to fit. Useful when
* working on large images.
*/
shell_width = MIN (shell_width, monitor_width);
shell_height = MIN (shell_height, monitor_height);
}
if (display_width) *display_width = shell_width;
if (display_height) *display_height = shell_height;
}
/**
* gimp_display_shell_scale:
* @shell: the #GimpDisplayShell
* @zoom_type: whether to zoom in, our or to a specific scale
* @scale: ignored unless @zoom_type == %GIMP_ZOOM_TO
*
* This function figures out the context of the zoom and behaves
* appropriatley thereafter.
*
**/
void
gimp_display_shell_scale (GimpDisplayShell *shell,
GimpZoomType zoom_type,
gdouble new_scale,
GimpZoomFocus zoom_focus)
{
gint x, y;
gdouble current_scale;
gdouble real_new_scale;
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
g_return_if_fail (shell->canvas != NULL);
current_scale = gimp_zoom_model_get_factor (shell->zoom);
if (zoom_type != GIMP_ZOOM_TO)
{
real_new_scale = gimp_zoom_model_zoom_step (zoom_type, current_scale);
}
else
{
real_new_scale = new_scale;
}
if (! SCALE_EQUALS (real_new_scale, current_scale))
{
if (shell->display->config->resize_windows_on_zoom)
{
GimpImageWindow *window = gimp_display_shell_get_window (shell);
/* If the window is resized on zoom, simply do the zoom and
* get things rolling
*/
gimp_zoom_model_zoom (shell->zoom, GIMP_ZOOM_TO, real_new_scale);
gimp_display_shell_scaled (shell);
if (window && gimp_image_window_get_active_shell (window) == shell)
{
gimp_image_window_shrink_wrap (window, FALSE);
}
}
else
{
gboolean starts_fitting_horiz;
gboolean starts_fitting_vert;
gboolean zoom_focus_almost_centered_horiz;
gboolean zoom_focus_almost_centered_vert;
gboolean image_center_almost_centered_horiz;
gboolean image_center_almost_centered_vert;
gint image_center_x;
gint image_center_y;
gimp_display_shell_scale_get_zoom_focus (shell,
real_new_scale,
current_scale,
&x,
&y,
zoom_focus);
gimp_display_shell_scale_get_image_center_viewport (shell,
&image_center_x,
&image_center_y);
gimp_display_shell_scale_to (shell, real_new_scale, x, y);
/* If an image axis started to fit due to zooming out or if
* the focus point is as good as in the center, center on
* that axis
*/
gimp_display_shell_scale_image_starts_to_fit (shell,
real_new_scale,
current_scale,
&starts_fitting_horiz,
&starts_fitting_vert);
gimp_display_shell_scale_viewport_coord_almost_centered (shell,
x,
y,
&zoom_focus_almost_centered_horiz,
&zoom_focus_almost_centered_vert);
gimp_display_shell_scale_viewport_coord_almost_centered (shell,
image_center_x,
image_center_y,
&image_center_almost_centered_horiz,
&image_center_almost_centered_vert);
gimp_display_shell_scroll_center_image (shell,
starts_fitting_horiz ||
(zoom_focus_almost_centered_horiz &&
image_center_almost_centered_horiz),
starts_fitting_vert ||
(zoom_focus_almost_centered_vert &&
image_center_almost_centered_vert));
}
}
}