static void
gimp_display_shell_monitor_res_notify_handler (GObject *config,
GParamSpec *param_spec,
GimpDisplayShell *shell)
{
if (GIMP_DISPLAY_CONFIG (config)->monitor_res_from_gdk)
{
gimp_get_monitor_resolution (gtk_widget_get_screen (GTK_WIDGET (shell)),
gimp_widget_get_monitor (GTK_WIDGET (shell)),
&shell->monitor_xres,
&shell->monitor_yres);
}
else
{
shell->monitor_xres = GIMP_DISPLAY_CONFIG (config)->monitor_xres;
shell->monitor_yres = GIMP_DISPLAY_CONFIG (config)->monitor_yres;
}
gimp_display_shell_scale_update (shell);
if (! shell->dot_for_dot)
{
gimp_display_shell_scroll_clamp_and_update (shell);
gimp_display_shell_scaled (shell);
gimp_display_shell_expose_full (shell);
}
}
static gboolean
gimp_display_shell_update_title_idle (gpointer data)
{
GimpDisplayShell *shell;
GimpDisplayConfig *config;
gchar title[MAX_TITLE_BUF];
shell = GIMP_DISPLAY_SHELL (data);
config = GIMP_DISPLAY_CONFIG (shell->display->image->gimp->config);
shell->title_idle_id = 0;
/* format the title */
gimp_display_shell_format_title (shell, title, sizeof (title),
config->image_title_format);
gdk_window_set_title (GTK_WIDGET (shell)->window, title);
/* format the statusbar */
if (strcmp (config->image_title_format, config->image_status_format))
{
gimp_display_shell_format_title (shell, title, sizeof (title),
config->image_status_format);
}
gimp_statusbar_replace (GIMP_STATUSBAR (shell->statusbar), "title",
"%s", title);
return FALSE;
}
void
gimp_display_shell_close (GimpDisplayShell *shell,
gboolean kill_it)
{
GimpImage *image;
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
image = shell->display->image;
/* FIXME: gimp_busy HACK not really appropriate here because we only
* want to prevent the busy image and display to be closed. --Mitch
*/
if (image->gimp->busy)
return;
/* If the image has been modified, give the user a chance to save
* it before nuking it--this only applies if its the last view
* to an image canvas. (a image with disp_count = 1)
*/
if (! kill_it &&
image->disp_count == 1 &&
image->dirty &&
GIMP_DISPLAY_CONFIG (image->gimp->config)->confirm_on_close)
{
gimp_display_shell_close_dialog (shell, image);
}
else
{
gimp_display_delete (shell->display);
}
}
static void
gimp_display_shell_size_changed_handler (GimpImage *image,
GimpDisplayShell *shell)
{
gimp_display_shell_scale_resize (shell,
GIMP_DISPLAY_CONFIG (image->gimp->config)->resize_windows_on_resize,
TRUE);
}
static void
gimp_align_tool_oper_update (GimpTool *tool,
GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
GimpAlignTool *align_tool = GIMP_ALIGN_TOOL (tool);
GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (display->shell);
gint snap_distance;
snap_distance =
GIMP_DISPLAY_CONFIG (display->image->gimp->config)->snap_distance;
if (gimp_draw_tool_on_vectors (GIMP_DRAW_TOOL (tool), display,
coords, snap_distance, snap_distance,
NULL, NULL, NULL, NULL, NULL, NULL))
{
if ((state & GDK_SHIFT_MASK) && align_tool->selected_objects)
align_tool->function = ALIGN_TOOL_ADD_PATH;
else
align_tool->function = ALIGN_TOOL_PICK_PATH;
}
else if (gimp_display_shell_get_show_guides (shell) &&
(NULL != gimp_image_find_guide (display->image,
coords->x, coords->y,
FUNSCALEX (shell, snap_distance),
FUNSCALEY (shell, snap_distance))))
{
if ((state & GDK_SHIFT_MASK) && align_tool->selected_objects)
align_tool->function = ALIGN_TOOL_ADD_GUIDE;
else
align_tool->function = ALIGN_TOOL_PICK_GUIDE;
}
else
{
GimpLayer *layer = select_layer_by_coords (display->image,
coords->x, coords->y);
if (layer)
{
if ((state & GDK_SHIFT_MASK) && align_tool->selected_objects)
align_tool->function = ALIGN_TOOL_ADD_LAYER;
else
align_tool->function = ALIGN_TOOL_PICK_LAYER;
}
else
{
align_tool->function = ALIGN_TOOL_IDLE;
}
}
gimp_align_tool_status_update (tool, display, state, proximity);
}
static void
gimp_magnify_options_reset (GimpToolOptions *tool_options)
{
GParamSpec *pspec;
pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (tool_options),
"auto-resize");
if (pspec)
G_PARAM_SPEC_BOOLEAN (pspec)->default_value =
GIMP_DISPLAY_CONFIG (tool_options->tool_info->gimp->config)->resize_windows_on_zoom;
GIMP_TOOL_OPTIONS_CLASS (parent_class)->reset (tool_options);
}
/* Returns: %TRUE if the XOR color is not white */
static gboolean
gimp_canvas_get_xor_color (GimpCanvas *canvas,
GdkColor *color)
{
GimpDisplayConfig *config = GIMP_DISPLAY_CONFIG (canvas->gimp->config);
guchar r, g, b;
gimp_rgb_get_uchar (&config->xor_color, &r, &g, &b);
color->red = (r << 8) | r;
color->green = (g << 8) | g;
color->blue = (b << 8) | b;
return (r != 255 || g != 255 || b != 255);
}
static void
gimp_display_shell_padding_notify_handler (GObject *config,
GParamSpec *param_spec,
GimpDisplayShell *shell)
{
GimpDisplayConfig *display_config;
gboolean fullscreen;
GimpCanvasPaddingMode padding_mode;
GimpRGB padding_color;
display_config = GIMP_DISPLAY_CONFIG (shell->display->image->gimp->config);
fullscreen = gimp_display_shell_get_fullscreen (shell);
/* if the user did not set the padding mode for this display explicitely */
if (! shell->fullscreen_options->padding_mode_set)
{
padding_mode = display_config->default_fullscreen_view->padding_mode;
padding_color = display_config->default_fullscreen_view->padding_color;
if (fullscreen)
{
gimp_display_shell_set_padding (shell, padding_mode, &padding_color);
}
else
{
shell->fullscreen_options->padding_mode = padding_mode;
shell->fullscreen_options->padding_color = padding_color;
}
}
/* if the user did not set the padding mode for this display explicitely */
if (! shell->options->padding_mode_set)
{
padding_mode = display_config->default_view->padding_mode;
padding_color = display_config->default_view->padding_color;
if (fullscreen)
{
shell->options->padding_mode = padding_mode;
shell->options->padding_color = padding_color;
}
else
{
gimp_display_shell_set_padding (shell, padding_mode, &padding_color);
}
}
}
void
gimp_display_shell_title_init (GimpDisplayShell *shell)
{
GimpDisplayConfig *config;
gchar title[MAX_TITLE_BUF];
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
config = GIMP_DISPLAY_CONFIG (shell->display->image->gimp->config);
gimp_display_shell_format_title (shell, title, sizeof (title),
config->image_status_format);
gimp_statusbar_push (GIMP_STATUSBAR (shell->statusbar), "title",
"%s", title);
}
static void
gimp_paint_tool_constructed (GObject *object)
{
GimpTool *tool = GIMP_TOOL (object);
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (object);
GimpPaintOptions *options = GIMP_PAINT_TOOL_GET_OPTIONS (tool);
GimpDisplayConfig *display_config;
GimpPaintInfo *paint_info;
G_OBJECT_CLASS (parent_class)->constructed (object);
g_assert (GIMP_IS_TOOL_INFO (tool->tool_info));
g_assert (GIMP_IS_PAINT_INFO (tool->tool_info->paint_info));
display_config = GIMP_DISPLAY_CONFIG (tool->tool_info->gimp->config);
paint_info = tool->tool_info->paint_info;
g_assert (g_type_is_a (paint_info->paint_type, GIMP_TYPE_PAINT_CORE));
paint_tool->core = g_object_new (paint_info->paint_type,
"undo-desc", paint_info->blurb,
NULL);
g_signal_connect_object (options, "notify::hard",
G_CALLBACK (gimp_paint_tool_hard_notify),
tool, 0);
gimp_paint_tool_hard_notify (options, NULL, tool);
paint_tool->show_cursor = display_config->show_paint_tool_cursor;
paint_tool->draw_brush = display_config->show_brush_outline;
g_signal_connect_object (display_config, "notify::show-paint-tool-cursor",
G_CALLBACK (gimp_paint_tool_cursor_notify),
paint_tool, 0);
g_signal_connect_object (display_config, "notify::show-brush-outline",
G_CALLBACK (gimp_paint_tool_cursor_notify),
paint_tool, 0);
}
static void
gimp_color_tool_oper_update (GimpTool *tool,
GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
GimpColorTool *color_tool = GIMP_COLOR_TOOL (tool);
GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (display->shell);
GimpSamplePoint *sample_point = NULL;
if (color_tool->enabled &&
gimp_display_shell_get_show_sample_points (shell) && proximity)
{
gint snap_distance;
snap_distance =
GIMP_DISPLAY_CONFIG (display->image->gimp->config)->snap_distance;
sample_point =
gimp_image_find_sample_point (display->image,
coords->x, coords->y,
FUNSCALEX (shell, snap_distance),
FUNSCALEY (shell, snap_distance));
}
if (color_tool->sample_point && color_tool->sample_point != sample_point)
gimp_image_update_sample_point (shell->display->image,
color_tool->sample_point);
color_tool->sample_point = sample_point;
if (color_tool->sample_point)
gimp_display_shell_draw_sample_point (shell, color_tool->sample_point,
TRUE);
}
void
gimp_display_shell_render (GimpDisplayShell *shell,
gint x,
gint y,
gint w,
gint h,
GdkRectangle *highlight)
{
GimpProjection *projection;
GimpImage *image;
RenderInfo info;
GimpImageType type;
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
g_return_if_fail (w > 0 && h > 0);
image = shell->display->image;
projection = image->projection;
/* Initialize RenderInfo with values that don't change during the
* call of this function.
*/
info.shell = shell;
info.x = x + shell->offset_x;
info.y = y + shell->offset_y;
info.w = w;
info.h = h;
info.dest_bpp = 3;
info.dest_bpl = info.dest_bpp * GIMP_RENDER_BUF_WIDTH;
info.dest_width = info.dest_bpp * info.w;
switch (GIMP_DISPLAY_CONFIG (image->gimp->config)->zoom_quality)
{
case GIMP_ZOOM_QUALITY_LOW:
info.zoom_quality = GIMP_DISPLAY_ZOOM_FAST;
break;
case GIMP_ZOOM_QUALITY_HIGH:
info.zoom_quality = GIMP_DISPLAY_ZOOM_PIXEL_AA;
break;
}
if (GIMP_IMAGE_TYPE_HAS_ALPHA (gimp_projection_get_image_type (projection)))
{
gdouble opacity = gimp_projection_get_opacity (projection);
info.alpha = render_image_init_alpha (opacity * 255.999);
}
/* Setup RenderInfo for rendering a GimpProjection level. */
{
TileManager *src_tiles;
gint level;
level = gimp_projection_get_level (projection,
shell->scale_x,
shell->scale_y);
src_tiles = gimp_projection_get_tiles_at_level (projection, level);
gimp_display_shell_render_info_scale (&info, shell, src_tiles, level);
}
/* Currently, only RGBA and GRAYA projection types are used. */
type = gimp_projection_get_image_type (projection);
switch (type)
{
case GIMP_RGBA_IMAGE:
render_image_rgb_a (&info);
break;
case GIMP_GRAYA_IMAGE:
render_image_gray_a (&info);
break;
default:
g_warning ("%s: unsupported projection type (%d)", G_STRFUNC, type);
g_assert_not_reached ();
}
/* apply filters to the rendered projection */
if (shell->filter_stack)
gimp_color_display_stack_convert (shell->filter_stack,
shell->render_buf,
w, h,
3,
3 * GIMP_RENDER_BUF_WIDTH);
/* dim pixels outside the highlighted rectangle */
if (highlight)
{
gimp_display_shell_render_highlight (shell, x, y, w, h, highlight);
}
else if (shell->mask)
{
TileManager *src_tiles = gimp_drawable_get_tiles (shell->mask);
/* The mask does not (yet) have an image pyramid, use 0 as level, */
gimp_display_shell_render_info_scale (&info, shell, src_tiles, 0);
gimp_display_shell_render_mask (shell, &info);
}
/* put it to the screen */
gimp_canvas_draw_rgb (GIMP_CANVAS (shell->canvas), GIMP_CANVAS_STYLE_RENDER,
x + shell->disp_xoffset, y + shell->disp_yoffset,
w, h,
shell->render_buf,
3 * GIMP_RENDER_BUF_WIDTH,
shell->offset_x, shell->offset_y);
}
void
view_actions_setup (GimpActionGroup *group)
{
GtkAction *action;
gimp_action_group_add_actions (group, "view-action",
view_actions,
G_N_ELEMENTS (view_actions));
gimp_action_group_add_toggle_actions (group, "view-action",
view_toggle_actions,
G_N_ELEMENTS (view_toggle_actions));
gimp_action_group_add_enum_actions (group, "view-zoom-action",
view_zoom_actions,
G_N_ELEMENTS (view_zoom_actions),
G_CALLBACK (view_zoom_cmd_callback));
gimp_action_group_add_radio_actions (group, "view-zoom-action",
view_zoom_explicit_actions,
G_N_ELEMENTS (view_zoom_explicit_actions),
NULL,
10000,
G_CALLBACK (view_zoom_explicit_cmd_callback));
gimp_action_group_add_enum_actions (group, "view-padding-color",
view_padding_color_actions,
G_N_ELEMENTS (view_padding_color_actions),
G_CALLBACK (view_padding_color_cmd_callback));
gimp_action_group_add_enum_actions (group, NULL,
view_scroll_horizontal_actions,
G_N_ELEMENTS (view_scroll_horizontal_actions),
G_CALLBACK (view_scroll_horizontal_cmd_callback));
gimp_action_group_add_enum_actions (group, NULL,
view_scroll_vertical_actions,
G_N_ELEMENTS (view_scroll_vertical_actions),
G_CALLBACK (view_scroll_vertical_cmd_callback));
/* connect "activate" of view-zoom-other manually so it can be
* selected even if it's the active item of the radio group
*/
action = gtk_action_group_get_action (GTK_ACTION_GROUP (group),
"view-zoom-other");
g_signal_connect (action, "activate",
G_CALLBACK (view_zoom_other_cmd_callback),
group->user_data);
g_signal_connect_object (group->gimp->config, "notify::check-type",
G_CALLBACK (view_actions_check_type_notify),
group, 0);
view_actions_check_type_notify (GIMP_DISPLAY_CONFIG (group->gimp->config),
NULL, group);
if (GIMP_IS_IMAGE_WINDOW (group->user_data) ||
GIMP_IS_GIMP (group->user_data))
{
/* add window actions only if the context of the group is
* the display itself or the global popup (not if the context
* is a dock)
* (see dock-actions.c)
*/
window_actions_setup (group, GIMP_HELP_VIEW_CHANGE_SCREEN);
}
}
static void
gui_restore_callback (Gimp *gimp,
GimpInitStatusFunc status_callback)
{
GimpDisplayConfig *display_config = GIMP_DISPLAY_CONFIG (gimp->config);
GimpGuiConfig *gui_config = GIMP_GUI_CONFIG (gimp->config);
if (gimp->be_verbose)
g_print ("INIT: %s\n", G_STRFUNC);
gui_vtable_init (gimp);
if (! gui_config->show_tooltips)
gimp_help_disable_tooltips ();
g_signal_connect (gui_config, "notify::show-tooltips",
G_CALLBACK (gui_show_tooltips_notify),
gimp);
gimp_dialogs_show_help_button (gui_config->use_help &&
gui_config->show_help_button);
g_signal_connect (gui_config, "notify::use-help",
G_CALLBACK (gui_show_help_button_notify),
gimp);
g_signal_connect (gui_config, "notify::user-manual-online",
G_CALLBACK (gui_user_manual_notify),
gimp);
g_signal_connect (gui_config, "notify::show-help-button",
G_CALLBACK (gui_show_help_button_notify),
gimp);
g_signal_connect (gimp_get_user_context (gimp), "display-changed",
G_CALLBACK (gui_display_changed),
gimp);
/* make sure the monitor resolution is valid */
if (display_config->monitor_res_from_gdk ||
display_config->monitor_xres < GIMP_MIN_RESOLUTION ||
display_config->monitor_yres < GIMP_MIN_RESOLUTION)
{
gdouble xres, yres;
gimp_get_monitor_resolution (initial_screen,
initial_monitor,
&xres, &yres);
g_object_set (gimp->config,
"monitor-xresolution", xres,
"monitor-yresolution", yres,
"monitor-resolution-from-windowing-system", TRUE,
NULL);
}
actions_init (gimp);
menus_init (gimp, global_action_factory);
gimp_render_init (gimp);
dialogs_init (gimp, global_menu_factory);
gimp_clipboard_init (gimp);
gimp_clipboard_set_buffer (gimp, gimp->global_buffer);
g_signal_connect (gimp, "buffer-changed",
G_CALLBACK (gui_global_buffer_changed),
NULL);
gimp_devices_init (gimp);
gimp_controllers_init (gimp);
session_init (gimp);
g_type_class_unref (g_type_class_ref (GIMP_TYPE_COLOR_SELECTOR_PALETTE));
status_callback (NULL, _("Tool Options"), 1.0);
gimp_tools_restore (gimp);
}
GimpValueArray *
gimp_plug_in_manager_call_run (GimpPlugInManager *manager,
GimpContext *context,
GimpProgress *progress,
GimpPlugInProcedure *procedure,
GimpValueArray *args,
gboolean synchronous,
GimpObject *display)
{
GimpValueArray *return_vals = NULL;
GimpPlugIn *plug_in;
g_return_val_if_fail (GIMP_IS_PLUG_IN_MANAGER (manager), NULL);
g_return_val_if_fail (GIMP_IS_PDB_CONTEXT (context), NULL);
g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), NULL);
g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (procedure), NULL);
g_return_val_if_fail (args != NULL, NULL);
g_return_val_if_fail (display == NULL || GIMP_IS_OBJECT (display), NULL);
plug_in = gimp_plug_in_new (manager, context, progress, procedure, NULL);
if (plug_in)
{
GimpCoreConfig *core_config = manager->gimp->config;
GimpGeglConfig *gegl_config = GIMP_GEGL_CONFIG (core_config);
GimpDisplayConfig *display_config = GIMP_DISPLAY_CONFIG (core_config);
GimpGuiConfig *gui_config = GIMP_GUI_CONFIG (core_config);
GPConfig config;
GPProcRun proc_run;
gint display_ID;
GObject *screen;
gint monitor;
if (! gimp_plug_in_open (plug_in, GIMP_PLUG_IN_CALL_RUN, FALSE))
{
const gchar *name = gimp_object_get_name (plug_in);
GError *error = g_error_new (GIMP_PLUG_IN_ERROR,
GIMP_PLUG_IN_EXECUTION_FAILED,
_("Failed to run plug-in \"%s\""),
name);
g_object_unref (plug_in);
return_vals = gimp_procedure_get_return_values (GIMP_PROCEDURE (procedure),
FALSE, error);
g_error_free (error);
return return_vals;
}
display_ID = display ? gimp_get_display_ID (manager->gimp, display) : -1;
config.version = GIMP_PROTOCOL_VERSION;
config.tile_width = GIMP_PLUG_IN_TILE_WIDTH;
config.tile_height = GIMP_PLUG_IN_TILE_HEIGHT;
config.shm_ID = (manager->shm ?
gimp_plug_in_shm_get_ID (manager->shm) : -1);
config.check_size = display_config->transparency_size;
config.check_type = display_config->transparency_type;
config.show_help_button = (gui_config->use_help &&
gui_config->show_help_button);
config.use_cpu_accel = manager->gimp->use_cpu_accel;
config.use_opencl = gegl_config->use_opencl;
config.gimp_reserved_6 = 0;
config.gimp_reserved_7 = 0;
config.gimp_reserved_8 = 0;
config.install_cmap = FALSE;
config.show_tooltips = gui_config->show_tooltips;
config.min_colors = 144;
config.gdisp_ID = display_ID;
config.app_name = (gchar *) g_get_application_name ();
config.wm_class = (gchar *) gimp_get_program_class (manager->gimp);
config.display_name = gimp_get_display_name (manager->gimp,
display_ID,
&screen, &monitor);
config.monitor_number = monitor;
config.timestamp = gimp_get_user_time (manager->gimp);
proc_run.name = GIMP_PROCEDURE (procedure)->original_name;
proc_run.nparams = gimp_value_array_length (args);
proc_run.params = plug_in_args_to_params (args, FALSE);
if (! gp_config_write (plug_in->my_write, &config, plug_in) ||
! gp_proc_run_write (plug_in->my_write, &proc_run, plug_in) ||
! gimp_wire_flush (plug_in->my_write, plug_in))
{
const gchar *name = gimp_object_get_name (plug_in);
GError *error = g_error_new (GIMP_PLUG_IN_ERROR,
GIMP_PLUG_IN_EXECUTION_FAILED,
_("Failed to run plug-in \"%s\""),
name);
g_free (config.display_name);
g_free (proc_run.params);
g_object_unref (plug_in);
return_vals = gimp_procedure_get_return_values (GIMP_PROCEDURE (procedure),
FALSE, error);
g_error_free (error);
return return_vals;
}
g_free (config.display_name);
g_free (proc_run.params);
/* If this is an extension,
* wait for an installation-confirmation message
*/
if (GIMP_PROCEDURE (procedure)->proc_type == GIMP_EXTENSION)
{
plug_in->ext_main_loop = g_main_loop_new (NULL, FALSE);
gimp_threads_leave (manager->gimp);
g_main_loop_run (plug_in->ext_main_loop);
gimp_threads_enter (manager->gimp);
/* main_loop is quit in gimp_plug_in_handle_extension_ack() */
g_main_loop_unref (plug_in->ext_main_loop);
plug_in->ext_main_loop = NULL;
}
/* If this plug-in is requested to run synchronously,
* wait for its return values
*/
if (synchronous)
{
GimpPlugInProcFrame *proc_frame = &plug_in->main_proc_frame;
proc_frame->main_loop = g_main_loop_new (NULL, FALSE);
gimp_threads_leave (manager->gimp);
g_main_loop_run (proc_frame->main_loop);
gimp_threads_enter (manager->gimp);
/* main_loop is quit in gimp_plug_in_handle_proc_return() */
g_main_loop_unref (proc_frame->main_loop);
proc_frame->main_loop = NULL;
return_vals = gimp_plug_in_proc_frame_get_return_values (proc_frame);
}
g_object_unref (plug_in);
}
return return_vals;
}
/*
* some rather complex logic here. If the user clicks without modifiers,
* then we start a new list, and use the first object in it as reference.
* If the user clicks using Shift, or draws a rubber-band box, then
* we add objects to the list, but do not specify which one should
* be used as reference.
*/
static void
gimp_align_tool_button_release (GimpTool *tool,
GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonReleaseType release_type,
GimpDisplay *display)
{
GimpAlignTool *align_tool = GIMP_ALIGN_TOOL (tool);
GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (display->shell);
GObject *object = NULL;
GimpImage *image = display->image;
gint i;
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
if (release_type == GIMP_BUTTON_RELEASE_CANCEL)
{
align_tool->x1 = align_tool->x0;
align_tool->y1 = align_tool->y0;
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
return;
}
if (! (state & GDK_SHIFT_MASK)) /* start a new list */
{
clear_all_selected_objects (align_tool);
align_tool->set_reference = FALSE;
}
/* if mouse has moved less than EPSILON pixels since button press, select
the nearest thing, otherwise make a rubber-band rectangle */
if (hypot (coords->x - align_tool->x0, coords->y - align_tool->y0) < EPSILON)
{
GimpVectors *vectors;
GimpGuide *guide;
GimpLayer *layer;
gint snap_distance;
snap_distance =
GIMP_DISPLAY_CONFIG (display->image->gimp->config)->snap_distance;
if (gimp_draw_tool_on_vectors (GIMP_DRAW_TOOL (tool), display,
coords, snap_distance, snap_distance,
NULL, NULL, NULL, NULL, NULL,
&vectors))
{
object = G_OBJECT (vectors);
}
else if (gimp_display_shell_get_show_guides (shell) &&
(guide = gimp_image_find_guide (display->image,
coords->x, coords->y,
FUNSCALEX (shell, snap_distance),
FUNSCALEY (shell, snap_distance))))
{
object = G_OBJECT (guide);
}
else
{
if ((layer = select_layer_by_coords (display->image,
coords->x, coords->y)))
{
object = G_OBJECT (layer);
}
}
if (object)
{
if (! g_list_find (align_tool->selected_objects, object))
{
align_tool->selected_objects
= g_list_append (align_tool->selected_objects, object);
g_signal_connect (object, "removed",
G_CALLBACK (clear_selected_object),
(gpointer) align_tool);
/* if an object has been selected using unmodified click,
* it should be used as the reference
*/
if (! (state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK)))
align_tool->set_reference = TRUE;
}
}
}
else /* FIXME: look for vectors too */
{
gint X0 = MIN (coords->x, align_tool->x0);
gint X1 = MAX (coords->x, align_tool->x0);
gint Y0 = MIN (coords->y, align_tool->y0);
gint Y1 = MAX (coords->y, align_tool->y0);
GList *list;
for (list = GIMP_LIST (image->layers)->list;
list;
list = g_list_next (list))
{
GimpLayer *layer = list->data;
gint x0, y0, x1, y1;
if (! gimp_item_get_visible (GIMP_ITEM (layer)))
continue;
gimp_item_offsets (GIMP_ITEM (layer), &x0, &y0);
x1 = x0 + gimp_item_width (GIMP_ITEM (layer));
y1 = y0 + gimp_item_height (GIMP_ITEM (layer));
if (x0 < X0 || y0 < Y0 || x1 > X1 || y1 > Y1)
continue;
if (g_list_find (align_tool->selected_objects, layer))
continue;
align_tool->selected_objects
= g_list_append (align_tool->selected_objects, layer);
g_signal_connect (layer, "removed", G_CALLBACK (clear_selected_object),
(gpointer) align_tool);
}
}
for (i = 0; i < ALIGN_TOOL_NUM_BUTTONS; i++)
gtk_widget_set_sensitive (align_tool->button[i],
(align_tool->selected_objects != NULL));
align_tool->x1 = align_tool->x0;
align_tool->y1 = align_tool->y0;
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
}
void
gimp_display_shell_disconnect (GimpDisplayShell *shell)
{
GimpImage *image;
GimpDisplayConfig *display_config;
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
g_return_if_fail (GIMP_IS_DISPLAY (shell->display));
g_return_if_fail (GIMP_IS_IMAGE (shell->display->image));
image = shell->display->image;
display_config = GIMP_DISPLAY_CONFIG (image->gimp->config);
if (shell->icon_idle_id)
{
g_source_remove (shell->icon_idle_id);
shell->icon_idle_id = 0;
}
if (shell->grid_gc)
{
g_object_unref (shell->grid_gc);
shell->grid_gc = NULL;
}
if (shell->pen_gc)
{
g_object_unref (shell->pen_gc);
shell->pen_gc = NULL;
}
g_signal_handlers_disconnect_by_func (image->gimp->config,
gimp_display_shell_quality_notify_handler,
shell);
g_signal_handlers_disconnect_by_func (image->gimp->config,
gimp_display_shell_ants_speed_notify_handler,
shell);
g_signal_handlers_disconnect_by_func (display_config->default_fullscreen_view,
gimp_display_shell_padding_notify_handler,
shell);
g_signal_handlers_disconnect_by_func (display_config->default_view,
gimp_display_shell_padding_notify_handler,
shell);
g_signal_handlers_disconnect_by_func (image->gimp->config,
gimp_display_shell_monitor_res_notify_handler,
shell);
g_signal_handlers_disconnect_by_func (image->gimp->config,
gimp_display_shell_nav_size_notify_handler,
shell);
g_signal_handlers_disconnect_by_func (image->gimp->config,
gimp_display_shell_title_notify_handler,
shell);
g_signal_handlers_disconnect_by_func (image->gimp->config,
gimp_display_shell_check_notify_handler,
shell);
g_signal_handlers_disconnect_by_func (image->vectors,
gimp_display_shell_vectors_remove_handler,
shell);
g_signal_handlers_disconnect_by_func (image->vectors,
gimp_display_shell_vectors_add_handler,
shell);
gimp_container_remove_handler (image->vectors,
shell->vectors_visible_handler);
gimp_container_remove_handler (image->vectors,
shell->vectors_thaw_handler);
gimp_container_remove_handler (image->vectors,
shell->vectors_freeze_handler);
g_signal_handlers_disconnect_by_func (image,
gimp_display_shell_profile_changed_handler,
shell);
g_signal_handlers_disconnect_by_func (image,
gimp_display_shell_invalidate_preview_handler,
shell);
g_signal_handlers_disconnect_by_func (image,
gimp_display_shell_update_guide_handler,
shell);
g_signal_handlers_disconnect_by_func (image,
gimp_display_shell_update_sample_point_handler,
shell);
g_signal_handlers_disconnect_by_func (image,
gimp_display_shell_quick_mask_changed_handler,
shell);
g_signal_handlers_disconnect_by_func (image,
gimp_display_shell_resolution_changed_handler,
shell);
g_signal_handlers_disconnect_by_func (image,
gimp_display_shell_size_changed_handler,
shell);
g_signal_handlers_disconnect_by_func (image,
gimp_display_shell_selection_control_handler,
shell);
g_signal_handlers_disconnect_by_func (image,
gimp_display_shell_name_changed_handler,
shell);
g_signal_handlers_disconnect_by_func (image->grid,
gimp_display_shell_grid_notify_handler,
shell);
g_signal_handlers_disconnect_by_func (image,
gimp_display_shell_undo_event_handler,
shell);
g_signal_handlers_disconnect_by_func (image,
gimp_display_shell_clean_dirty_handler,
shell);
}
void
gimp_display_shell_connect (GimpDisplayShell *shell)
{
GimpImage *image;
GimpDisplayConfig *display_config;
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
g_return_if_fail (GIMP_IS_DISPLAY (shell->display));
g_return_if_fail (GIMP_IS_IMAGE (shell->display->image));
image = shell->display->image;
display_config = GIMP_DISPLAY_CONFIG (image->gimp->config);
g_signal_connect (image, "clean",
G_CALLBACK (gimp_display_shell_clean_dirty_handler),
shell);
g_signal_connect (image, "dirty",
G_CALLBACK (gimp_display_shell_clean_dirty_handler),
shell);
g_signal_connect (image, "undo-event",
G_CALLBACK (gimp_display_shell_undo_event_handler),
shell);
g_signal_connect (image->grid, "notify",
G_CALLBACK (gimp_display_shell_grid_notify_handler),
shell);
g_signal_connect (image, "name-changed",
G_CALLBACK (gimp_display_shell_name_changed_handler),
shell);
g_signal_connect (image, "selection-control",
G_CALLBACK (gimp_display_shell_selection_control_handler),
shell);
g_signal_connect (image, "size-changed",
G_CALLBACK (gimp_display_shell_size_changed_handler),
shell);
g_signal_connect (image, "resolution-changed",
G_CALLBACK (gimp_display_shell_resolution_changed_handler),
shell);
g_signal_connect (image, "quick-mask-changed",
G_CALLBACK (gimp_display_shell_quick_mask_changed_handler),
shell);
g_signal_connect (image, "update-guide",
G_CALLBACK (gimp_display_shell_update_guide_handler),
shell);
g_signal_connect (image, "update-sample-point",
G_CALLBACK (gimp_display_shell_update_sample_point_handler),
shell);
g_signal_connect (image, "invalidate-preview",
G_CALLBACK (gimp_display_shell_invalidate_preview_handler),
shell);
g_signal_connect (image, "profile-changed",
G_CALLBACK (gimp_display_shell_profile_changed_handler),
shell);
shell->vectors_freeze_handler =
gimp_container_add_handler (image->vectors, "freeze",
G_CALLBACK (gimp_display_shell_vectors_freeze_handler),
shell);
shell->vectors_thaw_handler =
gimp_container_add_handler (image->vectors, "thaw",
G_CALLBACK (gimp_display_shell_vectors_thaw_handler),
shell);
shell->vectors_visible_handler =
gimp_container_add_handler (image->vectors, "visibility-changed",
G_CALLBACK (gimp_display_shell_vectors_visible_handler),
shell);
g_signal_connect (image->vectors, "add",
G_CALLBACK (gimp_display_shell_vectors_add_handler),
shell);
g_signal_connect (image->vectors, "remove",
G_CALLBACK (gimp_display_shell_vectors_remove_handler),
shell);
g_signal_connect (image->gimp->config,
"notify::transparency-size",
G_CALLBACK (gimp_display_shell_check_notify_handler),
shell);
g_signal_connect (image->gimp->config,
"notify::transparency-type",
G_CALLBACK (gimp_display_shell_check_notify_handler),
shell);
g_signal_connect (image->gimp->config,
"notify::image-title-format",
G_CALLBACK (gimp_display_shell_title_notify_handler),
shell);
g_signal_connect (image->gimp->config,
"notify::image-status-format",
G_CALLBACK (gimp_display_shell_title_notify_handler),
shell);
g_signal_connect (image->gimp->config,
"notify::navigation-preview-size",
G_CALLBACK (gimp_display_shell_nav_size_notify_handler),
shell);
g_signal_connect (image->gimp->config,
"notify::monitor-resolution-from-windowing-system",
G_CALLBACK (gimp_display_shell_monitor_res_notify_handler),
shell);
g_signal_connect (image->gimp->config,
"notify::monitor-xresolution",
G_CALLBACK (gimp_display_shell_monitor_res_notify_handler),
shell);
g_signal_connect (image->gimp->config,
"notify::monitor-yresolution",
G_CALLBACK (gimp_display_shell_monitor_res_notify_handler),
shell);
g_signal_connect (display_config->default_view,
"notify::padding-mode",
G_CALLBACK (gimp_display_shell_padding_notify_handler),
shell);
g_signal_connect (display_config->default_view,
"notify::padding-color",
G_CALLBACK (gimp_display_shell_padding_notify_handler),
shell);
g_signal_connect (display_config->default_fullscreen_view,
"notify::padding-mode",
G_CALLBACK (gimp_display_shell_padding_notify_handler),
shell);
g_signal_connect (display_config->default_fullscreen_view,
"notify::padding-color",
G_CALLBACK (gimp_display_shell_padding_notify_handler),
shell);
g_signal_connect (image->gimp->config,
"notify::marching-ants-speed",
G_CALLBACK (gimp_display_shell_ants_speed_notify_handler),
shell);
g_signal_connect (image->gimp->config,
"notify::zoom-quality",
G_CALLBACK (gimp_display_shell_quality_notify_handler),
shell);
gimp_display_shell_invalidate_preview_handler (image, shell);
gimp_display_shell_quick_mask_changed_handler (image, shell);
}
static void
gimp_display_shell_real_set_cursor (GimpDisplayShell *shell,
GimpCursorType cursor_type,
GimpToolCursorType tool_cursor,
GimpCursorModifier modifier,
gboolean always_install)
{
GimpDisplayConfig *config;
GimpCursorFormat cursor_format;
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
config = GIMP_DISPLAY_CONFIG (shell->display->image->gimp->config);
if (cursor_type != GIMP_CURSOR_NONE &&
cursor_type != GIMP_CURSOR_BAD)
{
switch (config->cursor_mode)
{
case GIMP_CURSOR_MODE_TOOL_ICON:
break;
case GIMP_CURSOR_MODE_TOOL_CROSSHAIR:
if (cursor_type < GIMP_CURSOR_CORNER_TOP_LEFT ||
cursor_type > GIMP_CURSOR_SIDE_BOTTOM)
{
/* the corner and side cursors count as crosshair, so leave
* them and override everything else
*/
cursor_type = GIMP_CURSOR_CROSSHAIR_SMALL;
}
break;
case GIMP_CURSOR_MODE_CROSSHAIR:
cursor_type = GIMP_CURSOR_CROSSHAIR;
tool_cursor = GIMP_TOOL_CURSOR_NONE;
if (modifier != GIMP_CURSOR_MODIFIER_BAD)
{
/* the bad modifier is always shown */
modifier = GIMP_CURSOR_MODIFIER_NONE;
}
break;
}
}
cursor_format = GIMP_GUI_CONFIG (config)->cursor_format;
if (shell->cursor_format != cursor_format ||
shell->current_cursor != cursor_type ||
shell->tool_cursor != tool_cursor ||
shell->cursor_modifier != modifier ||
always_install)
{
shell->cursor_format = cursor_format;
shell->current_cursor = cursor_type;
shell->tool_cursor = tool_cursor;
shell->cursor_modifier = modifier;
gimp_cursor_set (shell->canvas, cursor_format,
cursor_type, tool_cursor, modifier);
}
}
