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; }