static void
gimp_display_shell_drop_drawable (GtkWidget *widget,
gint x,
gint y,
GimpViewable *viewable,
gpointer data)
{
GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (data);
GimpImage *image = gimp_display_get_image (shell->display);
GType new_type;
GimpItem *new_item;
GIMP_LOG (DND, NULL);
if (shell->display->gimp->busy)
return;
if (! image)
{
image = gimp_image_new_from_drawable (shell->display->gimp,
GIMP_DRAWABLE (viewable));
gimp_create_display (shell->display->gimp, image, GIMP_UNIT_PIXEL, 1.0,
G_OBJECT (gtk_widget_get_screen (widget)),
gimp_widget_get_monitor (widget));
g_object_unref (image);
return;
}
if (GIMP_IS_LAYER (viewable))
new_type = G_TYPE_FROM_INSTANCE (viewable);
else
new_type = GIMP_TYPE_LAYER;
new_item = gimp_item_convert (GIMP_ITEM (viewable), image, new_type);
if (new_item)
{
GimpLayer *new_layer = GIMP_LAYER (new_item);
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_PASTE,
_("Drop New Layer"));
gimp_display_shell_dnd_position_item (shell, image, new_item);
gimp_item_set_visible (new_item, TRUE, FALSE);
gimp_item_set_linked (new_item, FALSE, FALSE);
gimp_image_add_layer (image, new_layer,
GIMP_IMAGE_ACTIVE_PARENT, -1, TRUE);
gimp_image_undo_group_end (image);
gimp_display_shell_dnd_flush (shell, image);
}
}
static gboolean
gimp_dialog_factory_dialog_configure (GtkWidget *dialog,
GdkEventConfigure *cevent,
GimpDialogFactory *factory)
{
GimpDialogFactory *dialog_factory;
GimpDialogFactoryEntry *entry;
GList *list;
if (! g_list_find (factory->open_dialogs, dialog))
{
g_warning ("%s: dialog not registered", G_STRFUNC);
return FALSE;
}
dialog_factory = gimp_dialog_factory_from_widget (dialog, &entry);
if (! dialog_factory || (! entry && ! GIMP_IS_DOCK (dialog)))
{
g_warning ("%s: dialog was not created by a GimpDialogFactory",
G_STRFUNC);
return FALSE;
}
if (dialog_factory != factory)
{
g_warning ("%s: dialog was created by a different GimpDialogFactory",
G_STRFUNC);
return FALSE;
}
for (list = factory->session_infos; list; list = g_list_next (list))
{
GimpSessionInfo *session_info = list->data;
if (session_info->widget == dialog)
{
gimp_session_info_get_geometry (session_info);
GIMP_LOG (DIALOG_FACTORY,
"updated session info for \"%s\" from window geometry "
"(x=%d y=%d %dx%d)",
entry ? entry->identifier : "dock",
session_info->x, session_info->y,
session_info->width, session_info->height);
break;
}
}
return FALSE;
}
static void
gimp_display_shell_drop_color (GtkWidget *widget,
gint x,
gint y,
const GimpRGB *color,
gpointer data)
{
GIMP_LOG (DND, NULL);
gimp_display_shell_dnd_bucket_fill (GIMP_DISPLAY_SHELL (data),
GIMP_FG_BUCKET_FILL,
color, NULL);
}
static void
gimp_display_shell_drop_pattern (GtkWidget *widget,
gint x,
gint y,
GimpViewable *viewable,
gpointer data)
{
GIMP_LOG (DND, NULL);
if (GIMP_IS_PATTERN (viewable))
gimp_display_shell_dnd_bucket_fill (GIMP_DISPLAY_SHELL (data),
GIMP_PATTERN_BUCKET_FILL,
NULL, GIMP_PATTERN (viewable));
}
static void
gimp_display_shell_drop_component (GtkWidget *widget,
gint x,
gint y,
GimpImage *image,
GimpChannelType component,
gpointer data)
{
GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (data);
GimpImage *dest_image = shell->display->image;
GimpChannel *channel;
GimpItem *new_item;
const gchar *desc;
GIMP_LOG (DND, NULL);
if (shell->display->gimp->busy)
return;
if (! dest_image)
return;
channel = gimp_channel_new_from_component (image, component, NULL, NULL);
new_item = gimp_item_convert (GIMP_ITEM (channel),
dest_image, GIMP_TYPE_LAYER);
g_object_unref (channel);
if (new_item)
{
GimpLayer *new_layer = GIMP_LAYER (new_item);
gimp_enum_get_value (GIMP_TYPE_CHANNEL_TYPE, component,
NULL, NULL, &desc, NULL);
gimp_object_take_name (GIMP_OBJECT (new_layer),
g_strdup_printf (_("%s Channel Copy"), desc));
gimp_image_undo_group_start (dest_image, GIMP_UNDO_GROUP_EDIT_PASTE,
_("Drop New Layer"));
gimp_display_shell_dnd_position_item (shell, new_item);
gimp_image_add_layer (dest_image, new_layer, -1);
gimp_image_undo_group_end (dest_image);
gimp_display_shell_dnd_flush (shell, dest_image);
}
}
static void
gimp_plug_in_cleanup_item (GimpPlugInProcFrame *proc_frame,
GimpPlugInCleanupItem *cleanup)
{
GimpItem *item = cleanup->item;
if (cleanup->shadow_buffer)
{
GIMP_LOG (SHADOW_TILES,
"Freeing shadow buffer of drawable '%s' on behalf of '%s'.",
gimp_object_get_name (item),
gimp_procedure_get_label (proc_frame->procedure));
gimp_drawable_free_shadow_buffer (GIMP_DRAWABLE (item));
}
}
void
gimp_tool_set_modifier_state (GimpTool *tool,
GdkModifierType state,
GimpDisplay *display)
{
gboolean press;
g_return_if_fail (GIMP_IS_TOOL (tool));
g_return_if_fail (GIMP_IS_DISPLAY (display));
g_return_if_fail (gimp_tool_control_is_active (tool->control) == FALSE);
GIMP_LOG (TOOL_FOCUS, "tool: %p display: %p tool->focus_display: %p",
tool, display, tool->focus_display);
g_return_if_fail (display == tool->focus_display);
if (state_changed (tool->modifier_state, state, GDK_SHIFT_MASK, &press))
{
gimp_tool_modifier_key (tool, GDK_SHIFT_MASK,
press, state,
display);
}
if (state_changed (tool->modifier_state, state, GDK_CONTROL_MASK, &press))
{
gimp_tool_modifier_key (tool, GDK_CONTROL_MASK,
press, state,
display);
}
if (state_changed (tool->modifier_state, state, GDK_MOD1_MASK, &press))
{
gimp_tool_modifier_key (tool, GDK_MOD1_MASK,
press, state,
display);
}
if (state_changed (tool->modifier_state, state, GDK_MOD2_MASK, &press))
{
gimp_tool_modifier_key (tool, GDK_MOD2_MASK,
press, state,
display);
}
tool->modifier_state = state;
}
static void
gimp_plug_in_cleanup_item (GimpPlugInProcFrame *proc_frame,
GimpPlugInCleanupItem *cleanup)
{
GimpItem *item = cleanup->item;
if (cleanup->shadow_tiles)
{
GimpProcedure *proc = proc_frame->procedure;
GIMP_LOG (SHADOW_TILES,
"Freeing shadow tiles of drawable '%s' on behalf of '%s'.",
gimp_object_get_name (item),
gimp_plug_in_procedure_get_label (GIMP_PLUG_IN_PROCEDURE (proc)));
gimp_drawable_free_shadow_tiles (GIMP_DRAWABLE (item));
}
}
static void
plug_in_menus_unregister_procedure (GimpPDB *pdb,
GimpProcedure *procedure,
GimpUIManager *manager)
{
if (GIMP_IS_PLUG_IN_PROCEDURE (procedure))
{
GimpPlugInProcedure *plug_in_proc = GIMP_PLUG_IN_PROCEDURE (procedure);
g_signal_handlers_disconnect_by_func (plug_in_proc,
plug_in_menus_menu_path_added,
manager);
if ((plug_in_proc->menu_label || plug_in_proc->menu_paths) &&
! plug_in_proc->file_proc)
{
GList *list;
GIMP_LOG (MENUS, "unregister procedure: %s",
gimp_object_get_name (procedure));
for (list = plug_in_proc->menu_paths; list; list = g_list_next (list))
{
if (g_str_has_prefix (list->data, manager->name))
{
gchar *merge_key;
guint merge_id;
merge_key = g_strdup_printf ("%s-merge-id",
gimp_object_get_name (plug_in_proc));
merge_id = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (manager),
merge_key));
g_free (merge_key);
if (merge_id)
gtk_ui_manager_remove_ui (GTK_UI_MANAGER (manager),
merge_id);
break;
}
}
}
}
}
static void
gimp_display_shell_drop_color (GtkWidget *widget,
gint x,
gint y,
const GimpRGB *color,
gpointer data)
{
GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (data);
GimpFillOptions *options = gimp_fill_options_new (shell->display->gimp,
NULL, FALSE);
GIMP_LOG (DND, NULL);
gimp_fill_options_set_style (options, GIMP_FILL_STYLE_SOLID);
gimp_context_set_foreground (GIMP_CONTEXT (options), color);
gimp_display_shell_dnd_fill (shell, options,
C_("undo-type", "Drop color to layer"));
g_object_unref (options);
}
static void
gimp_display_shell_drop_pattern (GtkWidget *widget,
gint x,
gint y,
GimpViewable *viewable,
gpointer data)
{
GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (data);
GimpFillOptions *options = gimp_fill_options_new (shell->display->gimp,
NULL, FALSE);
GIMP_LOG (DND, NULL);
gimp_fill_options_set_style (options, GIMP_FILL_STYLE_PATTERN);
gimp_context_set_pattern (GIMP_CONTEXT (options), GIMP_PATTERN (viewable));
gimp_display_shell_dnd_fill (shell, options,
C_("undo-type", "Drop pattern to layer"));
g_object_unref (options);
}
void
gimp_plug_in_shm_free (GimpPlugInShm *shm)
{
g_return_if_fail (shm != NULL);
if (shm->shm_ID != -1)
{
#if defined (USE_SYSV_SHM)
shmdt (shm->shm_addr);
#ifndef IPC_RMID_DEFERRED_RELEASE
shmctl (shm->shm_ID, IPC_RMID, NULL);
#endif
#elif defined(USE_WIN32_SHM)
if (shm->shm_handle)
CloseHandle (shm->shm_handle);
#elif defined(USE_POSIX_SHM)
gchar shm_handle[32];
munmap (shm->shm_addr, TILE_MAP_SIZE);
g_snprintf (shm_handle, sizeof (shm_handle), "/gimp-shm-%d",
shm->shm_ID);
shm_unlink (shm_handle);
#endif
GIMP_LOG (SHM, "detached shared memory segment ID = %d", shm->shm_ID);
}
g_slice_free (GimpPlugInShm, shm);
}
gboolean
gimp_text_tool_editor_key_release (GimpTextTool *text_tool,
GdkEventKey *kevent)
{
if (gtk_im_context_filter_keypress (text_tool->im_context, kevent))
{
text_tool->needs_im_reset = TRUE;
return TRUE;
}
gimp_text_tool_ensure_proxy (text_tool);
if (gtk_bindings_activate_event (GTK_OBJECT (text_tool->proxy_text_view),
kevent))
{
GIMP_LOG (TEXT_EDITING, "binding handled event");
return TRUE;
}
return FALSE;
}
static void
gimp_display_shell_drop_vectors (GtkWidget *widget,
gint x,
gint y,
GimpViewable *viewable,
gpointer data)
{
GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (data);
GimpImage *image = gimp_display_get_image (shell->display);
GimpItem *new_item;
GIMP_LOG (DND, NULL);
if (shell->display->gimp->busy)
return;
if (! image)
return;
new_item = gimp_item_convert (GIMP_ITEM (viewable),
image, G_TYPE_FROM_INSTANCE (viewable));
if (new_item)
{
GimpVectors *new_vectors = GIMP_VECTORS (new_item);
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_PASTE,
_("Drop New Path"));
gimp_image_add_vectors (image, new_vectors,
GIMP_IMAGE_ACTIVE_PARENT, -1, TRUE);
gimp_image_undo_group_end (image);
gimp_display_shell_dnd_flush (shell, image);
}
}
void
gimp_tool_set_focus_display (GimpTool *tool,
GimpDisplay *display)
{
g_return_if_fail (GIMP_IS_TOOL (tool));
g_return_if_fail (display == NULL || GIMP_IS_DISPLAY (display));
GIMP_LOG (TOOL_FOCUS, "tool: %p focus_display: %p tool->focus_display: %p",
tool, display, tool->focus_display);
if (display != tool->focus_display)
{
if (tool->focus_display)
{
if (tool->active_modifier_state != 0)
gimp_tool_set_active_modifier_state (tool, 0, tool->focus_display);
if (tool->modifier_state != 0)
gimp_tool_set_modifier_state (tool, 0, tool->focus_display);
}
tool->focus_display = display;
}
}
static void
gimp_display_shell_drop_svg (GtkWidget *widget,
gint x,
gint y,
const guchar *svg_data,
gsize svg_data_len,
gpointer data)
{
GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (data);
GimpImage *image = gimp_display_get_image (shell->display);
GError *error = NULL;
GIMP_LOG (DND, NULL);
if (shell->display->gimp->busy)
return;
if (! image)
return;
if (! gimp_vectors_import_buffer (image,
(const gchar *) svg_data, svg_data_len,
TRUE, FALSE,
GIMP_IMAGE_ACTIVE_PARENT, -1,
NULL, &error))
{
gimp_message_literal (shell->display->gimp, G_OBJECT (shell->display),
GIMP_MESSAGE_ERROR,
error->message);
g_clear_error (&error);
}
else
{
gimp_display_shell_dnd_flush (shell, image);
}
}
void
gimp_tool_set_modifier_state (GimpTool *tool,
GdkModifierType state,
GimpDisplay *display)
{
g_return_if_fail (GIMP_IS_TOOL (tool));
g_return_if_fail (GIMP_IS_DISPLAY (display));
GIMP_LOG (TOOL_FOCUS, "tool: %p display: %p tool->focus_display: %p",
tool, display, tool->focus_display);
g_return_if_fail (display == tool->focus_display);
if ((tool->modifier_state & GDK_SHIFT_MASK) != (state & GDK_SHIFT_MASK))
{
gimp_tool_modifier_key (tool, GDK_SHIFT_MASK,
(state & GDK_SHIFT_MASK) ? TRUE : FALSE, state,
display);
}
if ((tool->modifier_state & GDK_CONTROL_MASK) != (state & GDK_CONTROL_MASK))
{
gimp_tool_modifier_key (tool, GDK_CONTROL_MASK,
(state & GDK_CONTROL_MASK) ? TRUE : FALSE, state,
display);
}
if ((tool->modifier_state & GDK_MOD1_MASK) != (state & GDK_MOD1_MASK))
{
gimp_tool_modifier_key (tool, GDK_MOD1_MASK,
(state & GDK_MOD1_MASK) ? TRUE : FALSE, state,
display);
}
tool->modifier_state = state;
}
static void
gimp_display_shell_drop_pixbuf (GtkWidget *widget,
gint x,
gint y,
GdkPixbuf *pixbuf,
gpointer data)
{
GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (data);
GimpImage *image = shell->display->image;
GimpLayer *new_layer;
GimpImageType image_type;
gboolean new_image = FALSE;
GIMP_LOG (DND, NULL);
if (shell->display->gimp->busy)
return;
switch (gdk_pixbuf_get_n_channels (pixbuf))
{
case 1: image_type = GIMP_GRAY_IMAGE; break;
case 2: image_type = GIMP_GRAYA_IMAGE; break;
case 3: image_type = GIMP_RGB_IMAGE; break;
case 4: image_type = GIMP_RGBA_IMAGE; break;
break;
default:
g_return_if_reached ();
break;
}
if (! image)
{
image = gimp_create_image (shell->display->gimp,
gdk_pixbuf_get_width (pixbuf),
gdk_pixbuf_get_height (pixbuf),
GIMP_IMAGE_TYPE_BASE_TYPE (image_type),
FALSE);
gimp_create_display (image->gimp, image, GIMP_UNIT_PIXEL, 1.0);
g_object_unref (image);
gimp_image_undo_disable (image);
new_image = TRUE;
}
new_layer =
gimp_layer_new_from_pixbuf (pixbuf, image, image_type,
_("Dropped Buffer"),
GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE);
if (new_layer)
{
GimpItem *new_item = GIMP_ITEM (new_layer);
new_item = GIMP_ITEM (new_layer);
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_PASTE,
_("Drop New Layer"));
if (! new_image)
gimp_display_shell_dnd_position_item (shell, new_item);
gimp_image_add_layer (image, new_layer, -1);
gimp_image_undo_group_end (image);
gimp_display_shell_dnd_flush (shell, image);
}
if (new_image)
gimp_image_undo_enable (image);
}
static void
gimp_text_tool_delete_from_cursor (GimpTextTool *text_tool,
GtkDeleteType type,
gint count)
{
GtkTextBuffer *buffer = GTK_TEXT_BUFFER (text_tool->buffer);
GtkTextIter cursor;
GtkTextIter end;
GIMP_LOG (TEXT_EDITING, "%s count = %d",
g_enum_get_value (g_type_class_ref (GTK_TYPE_DELETE_TYPE),
type)->value_name,
count);
gimp_text_tool_reset_im_context (text_tool);
gtk_text_buffer_get_iter_at_mark (buffer, &cursor,
gtk_text_buffer_get_insert (buffer));
end = cursor;
switch (type)
{
case GTK_DELETE_CHARS:
if (gtk_text_buffer_get_has_selection (buffer))
{
gtk_text_buffer_delete_selection (buffer, TRUE, TRUE);
return;
}
else
{
gtk_text_iter_forward_cursor_positions (&end, count);
}
break;
case GTK_DELETE_WORD_ENDS:
if (count < 0)
{
if (! gtk_text_iter_starts_word (&cursor))
gtk_text_iter_backward_visible_word_starts (&cursor, 1);
}
else if (count > 0)
{
if (! gtk_text_iter_ends_word (&end) &&
! gtk_text_iter_forward_visible_word_ends (&end, 1))
gtk_text_iter_forward_to_line_end (&end);
}
break;
case GTK_DELETE_WORDS:
if (! gtk_text_iter_starts_word (&cursor))
gtk_text_iter_backward_visible_word_starts (&cursor, 1);
if (! gtk_text_iter_ends_word (&end) &&
! gtk_text_iter_forward_visible_word_ends (&end, 1))
gtk_text_iter_forward_to_line_end (&end);
break;
case GTK_DELETE_DISPLAY_LINES:
break;
case GTK_DELETE_DISPLAY_LINE_ENDS:
break;
case GTK_DELETE_PARAGRAPH_ENDS:
if (count < 0)
{
gtk_text_iter_set_line_offset (&cursor, 0);
}
else if (count > 0)
{
if (! gtk_text_iter_ends_line (&end))
gtk_text_iter_forward_to_line_end (&end);
else
gtk_text_iter_forward_cursor_positions (&end, 1);
}
break;
case GTK_DELETE_PARAGRAPHS:
break;
case GTK_DELETE_WHITESPACE:
find_whitepace_region (&cursor, &cursor, &end);
break;
}
if (! gtk_text_iter_equal (&cursor, &end))
{
gtk_text_buffer_delete_interactive (buffer, &cursor, &end, TRUE);
}
}
static void
gimp_display_shell_drop_uri_list (GtkWidget *widget,
gint x,
gint y,
GList *uri_list,
gpointer data)
{
GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (data);
GimpImage *image;
GimpContext *context;
GList *list;
gboolean open_as_layers;
/* If the app is already being torn down, shell->display might be NULL here.
* Play it safe. */
if (! shell->display)
{
return;
}
image = shell->display->image;
context = gimp_get_user_context (shell->display->gimp);
GIMP_LOG (DND, NULL);
open_as_layers = (shell->display->image != NULL);
for (list = uri_list; list; list = g_list_next (list))
{
const gchar *uri = list->data;
GimpPDBStatusType status;
GError *error = NULL;
gboolean warn = FALSE;
if (! shell->display)
{
/* It seems as if GIMP is being torn down for quitting. Bail out. */
return;
}
if (open_as_layers)
{
GList *new_layers;
new_layers = file_open_layers (shell->display->gimp, context,
GIMP_PROGRESS (shell->display),
image, FALSE,
uri, GIMP_RUN_INTERACTIVE, NULL,
&status, &error);
if (new_layers)
{
gint x, y;
gint width, height;
gimp_display_shell_untransform_viewport (shell, &x, &y,
&width, &height);
gimp_image_add_layers (image, new_layers, -1,
x, y, width, height,
_("Drop layers"));
g_list_free (new_layers);
}
else if (status != GIMP_PDB_CANCEL)
{
warn = TRUE;
}
}
else if (shell->display->image)
{
/* open any subsequent images in a new display */
GimpImage *new_image;
new_image = file_open_with_display (shell->display->gimp, context,
NULL,
uri, FALSE,
&status, &error);
if (! new_image && status != GIMP_PDB_CANCEL)
warn = TRUE;
}
else
{
/* open the first image in the empty display */
image = file_open_with_display (shell->display->gimp, context,
GIMP_PROGRESS (shell->display),
uri, FALSE,
&status, &error);
if (! image && status != GIMP_PDB_CANCEL)
warn = TRUE;
}
/* Something above might have run a few rounds of the main loop. Check
* that shell->display is still there, otherwise ignore this as the app
* is being torn down for quitting. */
if (warn && shell->display)
{
gchar *filename = file_utils_uri_display_name (uri);
gimp_message (shell->display->gimp, G_OBJECT (shell->display),
GIMP_MESSAGE_ERROR,
_("Opening '%s' failed:\n\n%s"),
filename, error->message);
g_clear_error (&error);
g_free (filename);
}
}
if (image)
gimp_display_shell_dnd_flush (shell, image);
}
GimpPlugInShm *
gimp_plug_in_shm_new (void)
{
/* allocate a piece of shared memory for use in transporting tiles
* to plug-ins. if we can't allocate a piece of shared memory then
* we'll fall back on sending the data over the pipe.
*/
GimpPlugInShm *shm = g_slice_new0 (GimpPlugInShm);
shm->shm_ID = -1;
#if defined(USE_SYSV_SHM)
/* Use SysV shared memory mechanisms for transferring tile data. */
{
shm->shm_ID = shmget (IPC_PRIVATE, TILE_MAP_SIZE, IPC_CREAT | 0600);
if (shm->shm_ID != -1)
{
shm->shm_addr = (guchar *) shmat (shm->shm_ID, NULL, 0);
if (shm->shm_addr == (guchar *) -1)
{
g_printerr ("shmat() failed: %s\n" ERRMSG_SHM_DISABLE,
g_strerror (errno));
shmctl (shm->shm_ID, IPC_RMID, NULL);
shm->shm_ID = -1;
}
#ifdef IPC_RMID_DEFERRED_RELEASE
if (shm->shm_addr != (guchar *) -1)
shmctl (shm->shm_ID, IPC_RMID, NULL);
#endif
}
else
{
g_printerr ("shmget() failed: %s\n" ERRMSG_SHM_DISABLE,
g_strerror (errno));
}
}
#elif defined(USE_WIN32_SHM)
/* Use Win32 shared memory mechanisms for transferring tile data. */
{
gint pid;
gchar fileMapName[MAX_PATH];
/* Our shared memory id will be our process ID */
pid = GetCurrentProcessId ();
/* From the id, derive the file map name */
g_snprintf (fileMapName, sizeof (fileMapName), "GIMP%d.SHM", pid);
/* Create the file mapping into paging space */
shm->shm_handle = CreateFileMapping (INVALID_HANDLE_VALUE, NULL,
PAGE_READWRITE, 0,
TILE_MAP_SIZE,
fileMapName);
if (shm->shm_handle)
{
/* Map the shared memory into our address space for use */
shm->shm_addr = (guchar *) MapViewOfFile (shm->shm_handle,
FILE_MAP_ALL_ACCESS,
0, 0, TILE_MAP_SIZE);
/* Verify that we mapped our view */
if (shm->shm_addr)
{
shm->shm_ID = pid;
}
else
{
g_printerr ("MapViewOfFile error: %d... " ERRMSG_SHM_DISABLE,
GetLastError ());
}
}
else
{
g_printerr ("CreateFileMapping error: %d... " ERRMSG_SHM_DISABLE,
GetLastError ());
}
}
#elif defined(USE_POSIX_SHM)
/* Use POSIX shared memory mechanisms for transferring tile data. */
{
gint pid;
gchar shm_handle[32];
gint shm_fd;
/* Our shared memory id will be our process ID */
pid = gimp_get_pid ();
/* From the id, derive the file map name */
g_snprintf (shm_handle, sizeof (shm_handle), "/gimp-shm-%d", pid);
/* Create the file mapping into paging space */
shm_fd = shm_open (shm_handle, O_RDWR | O_CREAT, 0600);
if (shm_fd != -1)
{
if (ftruncate (shm_fd, TILE_MAP_SIZE) != -1)
{
/* Map the shared memory into our address space for use */
shm->shm_addr = (guchar *) mmap (NULL, TILE_MAP_SIZE,
PROT_READ | PROT_WRITE, MAP_SHARED,
shm_fd, 0);
/* Verify that we mapped our view */
if (shm->shm_addr != MAP_FAILED)
{
shm->shm_ID = pid;
}
else
{
g_printerr ("mmap() failed: %s\n" ERRMSG_SHM_DISABLE,
g_strerror (errno));
shm_unlink (shm_handle);
}
}
else
{
g_printerr ("ftruncate() failed: %s\n" ERRMSG_SHM_DISABLE,
g_strerror (errno));
shm_unlink (shm_handle);
}
close (shm_fd);
}
else
{
g_printerr ("shm_open() failed: %s\n" ERRMSG_SHM_DISABLE,
g_strerror (errno));
}
}
#endif
if (shm->shm_ID == -1)
{
g_slice_free (GimpPlugInShm, shm);
shm = NULL;
}
else
{
GIMP_LOG (SHM, "attached shared memory segment ID = %d", shm->shm_ID);
}
return shm;
}
static void
gimp_display_shell_drop_drawable (GtkWidget *widget,
gint x,
gint y,
GimpViewable *viewable,
gpointer data)
{
GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (data);
GimpImage *image = shell->display->image;
GType new_type;
GimpItem *new_item;
gboolean new_image = FALSE;
GIMP_LOG (DND, NULL);
if (shell->display->gimp->busy)
return;
if (! image)
{
GimpImage *src_image = gimp_item_get_image (GIMP_ITEM (viewable));
GimpDrawable *drawable = GIMP_DRAWABLE (viewable);
GimpImageBaseType type;
gdouble xres;
gdouble yres;
type = GIMP_IMAGE_TYPE_BASE_TYPE (gimp_drawable_type (drawable));
image = gimp_create_image (shell->display->gimp,
gimp_item_width (GIMP_ITEM (viewable)),
gimp_item_height (GIMP_ITEM (viewable)),
type, TRUE);
gimp_image_undo_disable (image);
if (type == GIMP_INDEXED)
gimp_image_set_colormap (image,
gimp_image_get_colormap (src_image),
gimp_image_get_colormap_size (src_image),
FALSE);
gimp_image_get_resolution (src_image, &xres, &yres);
gimp_image_set_resolution (image, xres, yres);
gimp_image_set_unit (image, gimp_image_get_unit (src_image));
gimp_create_display (image->gimp, image, GIMP_UNIT_PIXEL, 1.0);
g_object_unref (image);
new_image = TRUE;
}
if (GIMP_IS_LAYER (viewable))
new_type = G_TYPE_FROM_INSTANCE (viewable);
else
new_type = GIMP_TYPE_LAYER;
new_item = gimp_item_convert (GIMP_ITEM (viewable), image, new_type);
if (new_item)
{
GimpLayer *new_layer = GIMP_LAYER (new_item);
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_PASTE,
_("Drop New Layer"));
if (! new_image)
gimp_display_shell_dnd_position_item (shell, new_item);
gimp_item_set_visible (new_item, TRUE, FALSE);
gimp_item_set_linked (new_item, FALSE, FALSE);
gimp_image_add_layer (image, new_layer, -1);
gimp_image_undo_group_end (image);
gimp_display_shell_dnd_flush (shell, image);
}
if (new_image)
gimp_image_undo_enable (image);
}
void
session_init (Gimp *gimp)
{
gchar *filename;
GScanner *scanner;
GTokenType token;
GError *error = NULL;
g_return_if_fail (GIMP_IS_GIMP (gimp));
filename = session_filename (gimp);
scanner = gimp_scanner_new_file (filename, &error);
if (! scanner && error->code == GIMP_CONFIG_ERROR_OPEN_ENOENT)
{
g_clear_error (&error);
g_free (filename);
filename = g_build_filename (gimp_sysconf_directory (),
"sessionrc", NULL);
scanner = gimp_scanner_new_file (filename, NULL);
}
if (! scanner)
{
g_clear_error (&error);
g_free (filename);
return;
}
if (gimp->be_verbose)
g_print ("Parsing '%s'\n", gimp_filename_to_utf8 (filename));
g_scanner_scope_add_symbol (scanner, 0, "session-info",
GINT_TO_POINTER (SESSION_INFO));
g_scanner_scope_add_symbol (scanner, 0, "hide-docks",
GINT_TO_POINTER (HIDE_DOCKS));
g_scanner_scope_add_symbol (scanner, 0, "single-window-mode",
GINT_TO_POINTER (SINGLE_WINDOW_MODE));
g_scanner_scope_add_symbol (scanner, 0, "last-tip-shown",
GINT_TO_POINTER (LAST_TIP_SHOWN));
token = G_TOKEN_LEFT_PAREN;
while (g_scanner_peek_next_token (scanner) == token)
{
token = g_scanner_get_next_token (scanner);
switch (token)
{
case G_TOKEN_LEFT_PAREN:
token = G_TOKEN_SYMBOL;
break;
case G_TOKEN_SYMBOL:
if (scanner->value.v_symbol == GINT_TO_POINTER (SESSION_INFO))
{
GimpDialogFactory *factory = NULL;
GimpSessionInfo *info = NULL;
gchar *factory_name = NULL;
gchar *entry_name = NULL;
GimpDialogFactoryEntry *entry = NULL;
token = G_TOKEN_STRING;
if (! gimp_scanner_parse_string (scanner, &factory_name))
break;
/* In versions <= GIMP 2.6 there was a "toolbox", a
* "dock", a "display" and a "toplevel" factory. These
* are now merged to a single gimp_dialog_factory_get_singleton (). We
* need the legacy name though, so keep it around.
*/
factory = gimp_dialog_factory_get_singleton ();
info = gimp_session_info_new ();
/* GIMP 2.6 has the entry name as part of the
* session-info header, so try to get it
*/
gimp_scanner_parse_string (scanner, &entry_name);
if (entry_name)
{
/* Previously, GimpDock was a toplevel. That is why
* versions <= GIMP 2.6 has "dock" as the entry name. We
* want "dock" to be interpreted as 'dock window'
* however so have some special-casing for that. When
* the entry name is "dock" the factory name is either
* "dock" or "toolbox".
*/
if (strcmp (entry_name, "dock") == 0)
{
entry =
gimp_dialog_factory_find_entry (factory,
(strcmp (factory_name, "toolbox") == 0 ?
"gimp-toolbox-window" :
"gimp-dock-window"));
}
else
{
entry = gimp_dialog_factory_find_entry (factory,
entry_name);
}
}
/* We're done with these now */
g_free (factory_name);
g_free (entry_name);
/* We can get the factory entry either now (the GIMP <=
* 2.6 way), or when we deserialize (the GIMP 2.8 way)
*/
if (entry)
{
gimp_session_info_set_factory_entry (info, entry);
}
/* Always try to deserialize */
if (gimp_config_deserialize (GIMP_CONFIG (info), scanner, 1, NULL))
{
/* Make sure we got a factory entry either the 2.6
* or 2.8 way
*/
if (gimp_session_info_get_factory_entry (info))
{
GIMP_LOG (DIALOG_FACTORY,
"successfully parsed and added session info %p",
info);
gimp_dialog_factory_add_session_info (factory, info);
}
else
{
GIMP_LOG (DIALOG_FACTORY,
"failed to parse session info %p, not adding",
info);
}
g_object_unref (info);
}
else
{
g_object_unref (info);
break;
}
}
else if (scanner->value.v_symbol == GINT_TO_POINTER (HIDE_DOCKS))
{
gboolean hide_docks;
token = G_TOKEN_IDENTIFIER;
if (! gimp_scanner_parse_boolean (scanner, &hide_docks))
break;
g_object_set (gimp->config,
"hide-docks", hide_docks,
NULL);
}
else if (scanner->value.v_symbol == GINT_TO_POINTER (SINGLE_WINDOW_MODE))
{
gboolean single_window_mode;
token = G_TOKEN_IDENTIFIER;
if (! gimp_scanner_parse_boolean (scanner, &single_window_mode))
break;
g_object_set (gimp->config,
"single-window-mode", single_window_mode,
NULL);
}
else if (scanner->value.v_symbol == GINT_TO_POINTER (LAST_TIP_SHOWN))
{
gint last_tip_shown;
token = G_TOKEN_INT;
if (! gimp_scanner_parse_int (scanner, &last_tip_shown))
break;
g_object_set (gimp->config,
"last-tip-shown", last_tip_shown,
NULL);
}
token = G_TOKEN_RIGHT_PAREN;
break;
case G_TOKEN_RIGHT_PAREN:
token = G_TOKEN_LEFT_PAREN;
break;
default: /* do nothing */
break;
}
}
if (token != G_TOKEN_LEFT_PAREN)
{
g_scanner_get_next_token (scanner);
g_scanner_unexp_token (scanner, token, NULL, NULL, NULL,
_("fatal parse error"), TRUE);
}
if (error)
{
gimp_message_literal (gimp, NULL, GIMP_MESSAGE_ERROR, error->message);
g_clear_error (&error);
gimp_config_file_backup_on_error (filename, "sessionrc", NULL);
}
gimp_scanner_destroy (scanner);
g_free (filename);
dialogs_load_recent_docks (gimp);
}
static gboolean
gimp_window_key_press_event (GtkWidget *widget,
GdkEventKey *event)
{
GtkWindow *window = GTK_WINDOW (widget);
GtkWidget *focus = gtk_window_get_focus (window);
gboolean handled = FALSE;
/* we're overriding the GtkWindow implementation here to give
* the focus widget precedence over unmodified accelerators
* before the accelerator activation scheme.
*/
/* text widgets get all key events first */
if (GTK_IS_EDITABLE (focus) ||
GTK_IS_TEXT_VIEW (focus) ||
GIMP_IS_CANVAS (focus))
{
handled = gtk_window_propagate_key_event (window, event);
if (handled)
GIMP_LOG (KEY_EVENTS,
"handled by gtk_window_propagate_key_event(text_widget)");
}
/* invoke control/alt accelerators */
if (! handled && event->state & (GDK_CONTROL_MASK | GDK_MOD1_MASK))
{
handled = gtk_window_activate_key (window, event);
if (handled)
GIMP_LOG (KEY_EVENTS,
"handled by gtk_window_activate_key(modified)");
}
/* invoke focus widget handlers */
if (! handled)
{
handled = gtk_window_propagate_key_event (window, event);
if (handled)
GIMP_LOG (KEY_EVENTS,
"handled by gtk_window_propagate_key_event(other_widget)");
}
/* invoke non-(control/alt) accelerators */
if (! handled && ! (event->state & (GDK_CONTROL_MASK | GDK_MOD1_MASK)))
{
handled = gtk_window_activate_key (window, event);
if (handled)
GIMP_LOG (KEY_EVENTS,
"handled by gtk_window_activate_key(unmodified)");
}
/* chain up, bypassing gtk_window_key_press(), to invoke binding set */
if (! handled)
{
GtkWidgetClass *widget_class;
widget_class = g_type_class_peek_static (g_type_parent (GTK_TYPE_WINDOW));
handled = widget_class->key_press_event (widget, event);
if (handled)
GIMP_LOG (KEY_EVENTS,
"handled by widget_class->key_press_event()");
}
return handled;
}
static void
gimp_text_tool_move_cursor (GimpTextTool *text_tool,
GtkMovementStep step,
gint count,
gboolean extend_selection)
{
GtkTextBuffer *buffer = GTK_TEXT_BUFFER (text_tool->buffer);
GtkTextIter cursor;
GtkTextIter selection;
GtkTextIter *sel_start;
gboolean cancel_selection = FALSE;
gint x_pos = -1;
GIMP_LOG (TEXT_EDITING, "%s count = %d, select = %s",
g_enum_get_value (g_type_class_ref (GTK_TYPE_MOVEMENT_STEP),
step)->value_name,
count,
extend_selection ? "TRUE" : "FALSE");
gtk_text_buffer_get_iter_at_mark (buffer, &cursor,
gtk_text_buffer_get_insert (buffer));
gtk_text_buffer_get_iter_at_mark (buffer, &selection,
gtk_text_buffer_get_selection_bound (buffer));
if (extend_selection)
{
sel_start = &selection;
}
else
{
/* when there is a selection, moving the cursor without
* extending it should move the cursor to the end of the
* selection that is in moving direction
*/
if (count > 0)
gtk_text_iter_order (&selection, &cursor);
else
gtk_text_iter_order (&cursor, &selection);
sel_start = &cursor;
/* if we actually have a selection, just move *to* the beginning/end
* of the selection and not *from* there on LOGICAL_POSITIONS
* and VISUAL_POSITIONS movement
*/
if (! gtk_text_iter_equal (&cursor, &selection))
cancel_selection = TRUE;
}
switch (step)
{
case GTK_MOVEMENT_LOGICAL_POSITIONS:
if (! cancel_selection)
gtk_text_iter_forward_visible_cursor_positions (&cursor, count);
break;
case GTK_MOVEMENT_VISUAL_POSITIONS:
if (! cancel_selection)
{
PangoLayout *layout;
const gchar *text;
if (! gimp_text_tool_ensure_layout (text_tool))
break;
layout = gimp_text_layout_get_pango_layout (text_tool->layout);
text = pango_layout_get_text (layout);
while (count != 0)
{
const gunichar word_joiner = 8288; /*g_utf8_get_char(WORD_JOINER);*/
gint index;
gint trailing = 0;
gint new_index;
index = gimp_text_buffer_get_iter_index (text_tool->buffer,
&cursor, TRUE);
if (count > 0)
{
if (g_utf8_get_char (text + index) == word_joiner)
pango_layout_move_cursor_visually (layout, TRUE,
index, 0, 1,
&new_index, &trailing);
else
new_index = index;
pango_layout_move_cursor_visually (layout, TRUE,
new_index, trailing, 1,
&new_index, &trailing);
count--;
}
else
{
pango_layout_move_cursor_visually (layout, TRUE,
index, 0, -1,
&new_index, &trailing);
if (new_index != -1 && new_index != G_MAXINT &&
g_utf8_get_char (text + new_index) == word_joiner)
{
pango_layout_move_cursor_visually (layout, TRUE,
new_index, trailing, -1,
&new_index, &trailing);
}
count++;
}
if (new_index != G_MAXINT && new_index != -1)
index = new_index;
else
break;
gimp_text_buffer_get_iter_at_index (text_tool->buffer,
&cursor, index, TRUE);
gtk_text_iter_forward_chars (&cursor, trailing);
}
}
break;
case GTK_MOVEMENT_WORDS:
if (count < 0)
{
gtk_text_iter_backward_visible_word_starts (&cursor, -count);
}
else if (count > 0)
{
if (! gtk_text_iter_forward_visible_word_ends (&cursor, count))
gtk_text_iter_forward_to_line_end (&cursor);
}
break;
case GTK_MOVEMENT_DISPLAY_LINES:
{
GtkTextIter start;
GtkTextIter end;
gint cursor_index;
PangoLayout *layout;
PangoLayoutLine *layout_line;
PangoLayoutIter *layout_iter;
PangoRectangle logical;
gint line;
gint trailing;
gint i;
gtk_text_buffer_get_bounds (buffer, &start, &end);
cursor_index = gimp_text_buffer_get_iter_index (text_tool->buffer,
&cursor, TRUE);
if (! gimp_text_tool_ensure_layout (text_tool))
break;
layout = gimp_text_layout_get_pango_layout (text_tool->layout);
pango_layout_index_to_line_x (layout, cursor_index, FALSE,
&line, &x_pos);
layout_iter = pango_layout_get_iter (layout);
for (i = 0; i < line; i++)
pango_layout_iter_next_line (layout_iter);
pango_layout_iter_get_line_extents (layout_iter, NULL, &logical);
x_pos += logical.x;
pango_layout_iter_free (layout_iter);
/* try to go to the remembered x_pos if it exists *and* we are at
* the beginning or at the end of the current line
*/
if (text_tool->x_pos != -1 && (x_pos <= logical.x ||
x_pos >= logical.x + logical.width))
x_pos = text_tool->x_pos;
line += count;
if (line < 0)
{
cursor = start;
break;
}
else if (line >= pango_layout_get_line_count (layout))
{
cursor = end;
break;
}
layout_iter = pango_layout_get_iter (layout);
for (i = 0; i < line; i++)
pango_layout_iter_next_line (layout_iter);
layout_line = pango_layout_iter_get_line_readonly (layout_iter);
pango_layout_iter_get_line_extents (layout_iter, NULL, &logical);
pango_layout_iter_free (layout_iter);
pango_layout_line_x_to_index (layout_line, x_pos - logical.x,
&cursor_index, &trailing);
gimp_text_buffer_get_iter_at_index (text_tool->buffer, &cursor,
cursor_index, TRUE);
while (trailing--)
gtk_text_iter_forward_char (&cursor);
}
break;
case GTK_MOVEMENT_PAGES: /* well... */
case GTK_MOVEMENT_BUFFER_ENDS:
if (count < 0)
{
gtk_text_buffer_get_start_iter (buffer, &cursor);
}
else if (count > 0)
{
gtk_text_buffer_get_end_iter (buffer, &cursor);
}
break;
case GTK_MOVEMENT_PARAGRAPH_ENDS:
if (count < 0)
{
gtk_text_iter_set_line_offset (&cursor, 0);
}
else if (count > 0)
{
if (! gtk_text_iter_ends_line (&cursor))
gtk_text_iter_forward_to_line_end (&cursor);
}
break;
case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
if (count < 0)
{
gtk_text_iter_set_line_offset (&cursor, 0);
}
else if (count > 0)
{
if (! gtk_text_iter_ends_line (&cursor))
gtk_text_iter_forward_to_line_end (&cursor);
}
break;
default:
return;
}
text_tool->x_pos = x_pos;
gimp_draw_tool_pause (GIMP_DRAW_TOOL (text_tool));
gimp_text_tool_reset_im_context (text_tool);
gtk_text_buffer_select_range (buffer, &cursor, sel_start);
gimp_draw_tool_resume (GIMP_DRAW_TOOL (text_tool));
}
static gchar *
plug_in_menus_build_path (GimpUIManager *manager,
const gchar *ui_path,
guint merge_id,
const gchar *menu_path,
gboolean for_menu)
{
gchar *action_path;
if (! strchr (menu_path, '/'))
{
action_path = g_strdup (ui_path);
goto make_placeholder;
}
action_path = g_strdup_printf ("%s%s", ui_path, strchr (menu_path, '/'));
if (! gtk_ui_manager_get_widget (GTK_UI_MANAGER (manager), action_path))
{
gchar *parent_menu_path = g_strdup (menu_path);
gchar *parent_action_path = NULL;
gchar *menu_item_name;
menu_item_name = strrchr (parent_menu_path, '/');
*menu_item_name++ = '\0';
if (menu_item_name)
parent_action_path = plug_in_menus_build_path (manager,
ui_path, merge_id,
parent_menu_path, TRUE);
if (parent_action_path)
{
g_free (action_path);
action_path = g_strdup_printf ("%s/%s",
parent_action_path, menu_item_name);
if (! gtk_ui_manager_get_widget (GTK_UI_MANAGER (manager),
action_path))
{
GIMP_LOG (MENUS, "adding menu '%s' at path '%s' for action '%s'",
menu_item_name, action_path, menu_path);
gtk_ui_manager_add_ui (GTK_UI_MANAGER (manager), merge_id,
parent_action_path, menu_item_name,
menu_path,
GTK_UI_MANAGER_MENU,
FALSE);
gtk_ui_manager_add_ui (GTK_UI_MANAGER (manager), merge_id,
action_path, "Menus", NULL,
GTK_UI_MANAGER_PLACEHOLDER,
FALSE);
gtk_ui_manager_add_ui (GTK_UI_MANAGER (manager), merge_id,
action_path, "Separator", NULL,
GTK_UI_MANAGER_SEPARATOR,
FALSE);
}
g_free (parent_action_path);
}
else
{
g_free (action_path);
action_path = NULL;
}
g_free (parent_menu_path);
}
make_placeholder:
if (action_path && for_menu)
{
gchar *placeholder_path = g_strdup_printf ("%s/%s", action_path, "Menus");
if (gtk_ui_manager_get_widget (GTK_UI_MANAGER (manager),
placeholder_path))
{
g_free (action_path);
return placeholder_path;
}
g_free (placeholder_path);
}
return action_path;
}
static void
plug_in_menus_add_proc (GimpUIManager *manager,
const gchar *ui_path,
GimpPlugInProcedure *proc,
const gchar *menu_path)
{
gchar *path;
gchar *merge_key;
gchar *stripped_path;
gchar *action_path;
guint merge_id;
guint menu_merge_id;
g_return_if_fail (GIMP_IS_UI_MANAGER (manager));
g_return_if_fail (ui_path != NULL);
g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc));
path = g_strdup (menu_path);
if (! proc->menu_label)
{
gchar *p;
if (! path)
return;
p = strrchr (path, '/');
if (! p)
{
g_free (path);
return;
}
*p = '\0';
}
merge_key = g_strdup_printf ("%s-merge-id", gimp_object_get_name (proc));
merge_id = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (manager),
merge_key));
if (! merge_id)
{
merge_id = gtk_ui_manager_new_merge_id (GTK_UI_MANAGER (manager));
g_object_set_data (G_OBJECT (manager), merge_key,
GUINT_TO_POINTER (merge_id));
}
g_free (merge_key);
menu_merge_id = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (manager),
"plug-in-menu-merge-id"));
if (! menu_merge_id)
{
menu_merge_id = gtk_ui_manager_new_merge_id (GTK_UI_MANAGER (manager));
g_object_set_data (G_OBJECT (manager), "plug-in-menu-merge-id",
GUINT_TO_POINTER (menu_merge_id));
}
stripped_path = gimp_strip_uline (path);
action_path = plug_in_menus_build_path (manager, ui_path, menu_merge_id,
stripped_path, FALSE);
g_free (stripped_path);
if (! action_path)
{
g_free (path);
return;
}
GIMP_LOG (MENUS, "adding menu item for '%s' (@ %s)",
gimp_object_get_name (proc), action_path);
gtk_ui_manager_add_ui (GTK_UI_MANAGER (manager), merge_id,
action_path,
gimp_object_get_name (proc),
gimp_object_get_name (proc),
GTK_UI_MANAGER_MENUITEM,
FALSE);
g_free (action_path);
g_free (path);
}
static void
plug_in_menus_menu_path_added (GimpPlugInProcedure *plug_in_proc,
const gchar *menu_path,
GimpUIManager *manager)
{
GIMP_LOG (MENUS, "menu path added: %s (%s)",
gimp_object_get_name (plug_in_proc), menu_path);
if (g_str_has_prefix (menu_path, manager->name))
{
if (! strcmp (manager->name, "<Image>"))
{
plug_in_menus_add_proc (manager, "/image-menubar",
plug_in_proc, menu_path);
plug_in_menus_add_proc (manager, "/dummy-menubar/image-popup",
plug_in_proc, menu_path);
}
else if (! strcmp (manager->name, "<Toolbox>"))
{
plug_in_menus_add_proc (manager, "/toolbox-menubar",
plug_in_proc, menu_path);
}
else if (! strcmp (manager->name, "<Layers>"))
{
plug_in_menus_add_proc (manager, "/layers-popup",
plug_in_proc, menu_path);
}
else if (! strcmp (manager->name, "<Channels>"))
{
plug_in_menus_add_proc (manager, "/channels-popup",
plug_in_proc, menu_path);
}
else if (! strcmp (manager->name, "<Vectors>"))
{
plug_in_menus_add_proc (manager, "/vectors-popup",
plug_in_proc, menu_path);
}
else if (! strcmp (manager->name, "<Colormap>"))
{
plug_in_menus_add_proc (manager, "/colormap-popup",
plug_in_proc, menu_path);
}
else if (! strcmp (manager->name, "<Brushes>"))
{
plug_in_menus_add_proc (manager, "/brushes-popup",
plug_in_proc, menu_path);
}
else if (! strcmp (manager->name, "<Dynamics>"))
{
plug_in_menus_add_proc (manager, "/dynamics-popup",
plug_in_proc, menu_path);
}
else if (! strcmp (manager->name, "<Gradients>"))
{
plug_in_menus_add_proc (manager, "/gradients-popup",
plug_in_proc, menu_path);
}
else if (! strcmp (manager->name, "<Palettes>"))
{
plug_in_menus_add_proc (manager, "/palettes-popup",
plug_in_proc, menu_path);
}
else if (! strcmp (manager->name, "<Patterns>"))
{
plug_in_menus_add_proc (manager, "/patterns-popup",
plug_in_proc, menu_path);
}
else if (! strcmp (manager->name, "<ToolPresets>"))
{
plug_in_menus_add_proc (manager, "/tool-presets-popup",
plug_in_proc, menu_path);
}
else if (! strcmp (manager->name, "<Fonts>"))
{
plug_in_menus_add_proc (manager, "/fonts-popup",
plug_in_proc, menu_path);
}
else if (! strcmp (manager->name, "<Buffers>"))
{
plug_in_menus_add_proc (manager, "/buffers-popup",
plug_in_proc, menu_path);
}
}
}
void
gimp_tool_set_active_modifier_state (GimpTool *tool,
GdkModifierType state,
GimpDisplay *display)
{
g_return_if_fail (GIMP_IS_TOOL (tool));
g_return_if_fail (GIMP_IS_DISPLAY (display));
GIMP_LOG (TOOL_FOCUS, "tool: %p display: %p tool->focus_display: %p",
tool, display, tool->focus_display);
g_return_if_fail (display == tool->focus_display);
if ((tool->active_modifier_state & GDK_SHIFT_MASK) !=
(state & GDK_SHIFT_MASK))
{
gboolean press = state & GDK_SHIFT_MASK;
#ifdef DEBUG_ACTIVE_STATE
g_printerr ("%s: SHIFT %s\n", G_STRFUNC,
press ? "pressed" : "released");
#endif
if (! press && (tool->button_press_state & GDK_SHIFT_MASK))
{
tool->button_press_state &= ~GDK_SHIFT_MASK;
}
else
{
gimp_tool_active_modifier_key (tool, GDK_SHIFT_MASK,
press, state,
display);
}
}
if ((tool->active_modifier_state & GDK_CONTROL_MASK) !=
(state & GDK_CONTROL_MASK))
{
gboolean press = state & GDK_CONTROL_MASK;
#ifdef DEBUG_ACTIVE_STATE
g_printerr ("%s: CONTROL %s\n", G_STRFUNC,
press ? "pressed" : "released");
#endif
if (! press && (tool->button_press_state & GDK_CONTROL_MASK))
{
tool->button_press_state &= ~GDK_CONTROL_MASK;
}
else
{
gimp_tool_active_modifier_key (tool, GDK_CONTROL_MASK,
press, state,
display);
}
}
if ((tool->active_modifier_state & GDK_MOD1_MASK) !=
(state & GDK_MOD1_MASK))
{
gboolean press = state & GDK_MOD1_MASK;
#ifdef DEBUG_ACTIVE_STATE
g_printerr ("%s: ALT %s\n", G_STRFUNC,
press ? "pressed" : "released");
#endif
if (! press && (tool->button_press_state & GDK_MOD1_MASK))
{
tool->button_press_state &= ~GDK_MOD1_MASK;
}
else
{
gimp_tool_active_modifier_key (tool, GDK_MOD1_MASK,
press, state,
display);
}
}
tool->active_modifier_state = state;
}
gboolean
gimp_text_tool_editor_key_press (GimpTextTool *text_tool,
GdkEventKey *kevent)
{
GtkTextBuffer *buffer = GTK_TEXT_BUFFER (text_tool->buffer);
GtkTextIter cursor;
GtkTextIter selection;
gint x_pos = -1;
gboolean retval = TRUE;
if (gtk_im_context_filter_keypress (text_tool->im_context, kevent))
{
text_tool->needs_im_reset = TRUE;
text_tool->x_pos = -1;
return TRUE;
}
gimp_text_tool_ensure_proxy (text_tool);
if (gtk_bindings_activate_event (GTK_OBJECT (text_tool->proxy_text_view),
kevent))
{
GIMP_LOG (TEXT_EDITING, "binding handled event");
return TRUE;
}
gtk_text_buffer_get_iter_at_mark (buffer, &cursor,
gtk_text_buffer_get_insert (buffer));
gtk_text_buffer_get_iter_at_mark (buffer, &selection,
gtk_text_buffer_get_selection_bound (buffer));
switch (kevent->keyval)
{
case GDK_KEY_Return:
case GDK_KEY_KP_Enter:
case GDK_KEY_ISO_Enter:
gimp_text_tool_reset_im_context (text_tool);
gimp_text_tool_enter_text (text_tool, "\n");
break;
case GDK_KEY_Tab:
case GDK_KEY_KP_Tab:
case GDK_KEY_ISO_Left_Tab:
gimp_text_tool_reset_im_context (text_tool);
gimp_text_tool_enter_text (text_tool, "\t");
break;
case GDK_KEY_Escape:
gimp_rectangle_tool_cancel (GIMP_RECTANGLE_TOOL (text_tool));
gimp_tool_control (GIMP_TOOL (text_tool), GIMP_TOOL_ACTION_HALT,
GIMP_TOOL (text_tool)->display);
break;
default:
retval = FALSE;
}
text_tool->x_pos = x_pos;
return retval;
}
