void gimp_display_shell_clear_software_cursor (GimpDisplayShell *shell) { GimpStatusbar *statusbar; GimpSessionInfo *session_info; g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell)); gimp_canvas_item_set_visible (shell->cursor, FALSE); statusbar = gimp_display_shell_get_statusbar (shell); gimp_statusbar_clear_cursor (statusbar); session_info = gimp_dialog_factory_find_session_info (gimp_dialog_factory_get_singleton (), "gimp-cursor-view"); if (session_info && gimp_session_info_get_widget (session_info)) { GtkWidget *cursor_view; cursor_view = gtk_bin_get_child (GTK_BIN (gimp_session_info_get_widget (session_info))); if (cursor_view) gimp_cursor_view_clear_cursor (GIMP_CURSOR_VIEW (cursor_view)); } }
static gboolean dialogs_actions_toolbox_exists (Gimp *gimp) { GimpDialogFactory *factory = gimp_dialog_factory_get_singleton (); GimpSessionInfo *info = NULL; GList *windows = gimp ? gimp_get_image_windows (gimp) : NULL; gboolean toolbox_found = FALSE; GList *iter; /* First look in session managed windows */ info = gimp_dialog_factory_find_session_info (factory, "gimp-toolbox-window"); toolbox_found = info && gimp_session_info_get_widget (info); /* Then in image windows */ if (! toolbox_found) { for (iter = windows; iter; iter = g_list_next (iter)) { GimpImageWindow *window = GIMP_IMAGE_WINDOW (windows->data); if (gimp_image_window_has_toolbox (window)) { toolbox_found = TRUE; break; } } } return toolbox_found; }
/** * gimp_dialog_factory_dialog_raise: * @factory: a #GimpDialogFactory * @screen: the #GdkScreen the dialog should appear on * @identifiers: a '|' separated list of identifiers of dialogs as * registered with gimp_dialog_factory_register_entry() * @view_size: * * Raises any of a list of already existing toplevel dialog or * #GimpDockable if it was already created by this %facory. * * Implicitly creates the first dialog in the list if none of the dialogs * were found. * * Return value: the raised or newly created dialog. **/ GtkWidget * gimp_dialog_factory_dialog_raise (GimpDialogFactory *factory, GdkScreen *screen, const gchar *identifiers, gint view_size) { GtkWidget *dialog; g_return_val_if_fail (GIMP_IS_DIALOG_FACTORY (factory), NULL); g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL); g_return_val_if_fail (identifiers != NULL, NULL); /* If the identifier is a list, try to find a matching dialog and * raise it. If there's no match, use the first list item. */ if (strchr (identifiers, '|')) { gchar **ids = g_strsplit (identifiers, "|", 0); gint i; for (i = 0; ids[i]; i++) { GimpSessionInfo *info; info = gimp_dialog_factory_find_session_info (factory, ids[i]); if (info && info->widget) break; } dialog = gimp_dialog_factory_dialog_new_internal (factory, screen, NULL, ids[i] ? ids[i] : ids[0], view_size, TRUE, TRUE); g_strfreev (ids); } else { dialog = gimp_dialog_factory_dialog_new_internal (factory, screen, NULL, identifiers, view_size, TRUE, TRUE); } return dialog; }
static GimpColormapEditor * context_get_colormap_editor (void) { GimpSessionInfo *info = NULL; g_return_val_if_fail (GIMP_IS_DIALOG_FACTORY (gimp_dialog_factory_get_singleton ()), NULL); info = gimp_dialog_factory_find_session_info (gimp_dialog_factory_get_singleton (), "gimp-indexed-palette"); if (info && gimp_session_info_get_widget (info)) return GIMP_COLORMAP_EDITOR (gtk_bin_get_child (GTK_BIN (gimp_session_info_get_widget (info)))); return NULL; }
static GimpPaletteEditor * context_get_palette_editor (void) { GimpSessionInfo *info = NULL; g_return_val_if_fail (GIMP_IS_DIALOG_FACTORY (gimp_dialog_factory_get_singleton ()), NULL); info = gimp_dialog_factory_find_session_info (gimp_dialog_factory_get_singleton (), "gimp-palette-editor"); if (info && gimp_session_info_get_widget (info)) return GIMP_PALETTE_EDITOR (gtk_bin_get_child (GTK_BIN (gimp_session_info_get_widget (info)))); return NULL; }
void gimp_display_shell_clear_cursor (GimpDisplayShell *shell) { GimpDialogFactory *factory; GimpSessionInfo *session_info; g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell)); gimp_statusbar_clear_cursor (GIMP_STATUSBAR (shell->statusbar)); factory = gimp_dialog_factory_from_name ("dock"); session_info = gimp_dialog_factory_find_session_info (factory, "gimp-cursor-view"); if (session_info && session_info->widget) { GtkWidget *cursor_view; cursor_view = gtk_bin_get_child (GTK_BIN (session_info->widget)); if (cursor_view) gimp_cursor_view_clear_cursor (GIMP_CURSOR_VIEW (cursor_view)); } }
static gboolean gui_message_error_console (GimpMessageSeverity severity, const gchar *domain, const gchar *message) { GtkWidget *dockable = NULL; /* try to avoid raising the error console for not so severe messages */ if (severity < GIMP_MESSAGE_ERROR) { GimpSessionInfo *info; info = gimp_dialog_factory_find_session_info (global_dock_factory, "gimp-error-console"); if (info && GIMP_IS_DOCKABLE (info->widget)) dockable = info->widget; } if (! dockable) dockable = gimp_dialog_factory_dialog_raise (global_dock_factory, gdk_screen_get_default (), "gimp-error-console", -1); if (dockable) { GtkWidget *child = gtk_bin_get_child (GTK_BIN (dockable)); gimp_error_console_add (GIMP_ERROR_CONSOLE (child), severity, domain, message); return TRUE; } return FALSE; }
void gimp_display_shell_update_software_cursor (GimpDisplayShell *shell, GimpCursorPrecision precision, gint display_x, gint display_y, gdouble image_x, gdouble image_y) { GimpStatusbar *statusbar; GimpSessionInfo *session_info; GimpImage *image; g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell)); image = gimp_display_get_image (shell->display); if (shell->draw_cursor && shell->proximity && display_x >= 0 && display_y >= 0) { gimp_canvas_item_begin_change (shell->cursor); gimp_canvas_cursor_set (shell->cursor, display_x, display_y); gimp_canvas_item_set_visible (shell->cursor, TRUE); gimp_canvas_item_end_change (shell->cursor); } else { gimp_canvas_item_set_visible (shell->cursor, FALSE); } /* use the passed image_coords for the statusbar because they are * possibly snapped... */ statusbar = gimp_display_shell_get_statusbar (shell); gimp_statusbar_update_cursor (statusbar, precision, image_x, image_y); session_info = gimp_dialog_factory_find_session_info (gimp_dialog_factory_get_singleton (), "gimp-cursor-view"); if (session_info && gimp_session_info_get_widget (session_info)) { GtkWidget *cursor_view; cursor_view = gtk_bin_get_child (GTK_BIN (gimp_session_info_get_widget (session_info))); if (cursor_view) { gint t_x = -1; gint t_y = -1; /* ...but use the unsnapped display_coords for the info window */ if (display_x >= 0 && display_y >= 0) gimp_display_shell_untransform_xy (shell, display_x, display_y, &t_x, &t_y, FALSE); gimp_cursor_view_update_cursor (GIMP_CURSOR_VIEW (cursor_view), image, shell->unit, t_x, t_y); } } }
static void gimp_color_tool_real_picked (GimpColorTool *color_tool, GimpColorPickState pick_state, GimpImageType sample_type, GimpRGB *color, gint color_index) { GimpTool *tool = GIMP_TOOL (color_tool); GimpContext *context; GimpDialogFactory *dialog_factory; /* use this tool's own options here (NOT color_tool->options) */ context = GIMP_CONTEXT (gimp_tool_get_options (tool)); dialog_factory = gimp_dialog_factory_from_name ("dock"); if (color_tool->pick_mode == GIMP_COLOR_PICK_MODE_FOREGROUND || color_tool->pick_mode == GIMP_COLOR_PICK_MODE_BACKGROUND) { GimpSessionInfo *info; if (GIMP_IMAGE_TYPE_IS_INDEXED (sample_type)) { info = gimp_dialog_factory_find_session_info (dialog_factory, "gimp-indexed-palette"); if (info && info->widget) { GimpColormapEditor *editor; editor = GIMP_COLORMAP_EDITOR (gtk_bin_get_child (GTK_BIN (info->widget))); gimp_colormap_editor_set_index (editor, color_index, NULL); } } if (TRUE) { info = gimp_dialog_factory_find_session_info (dialog_factory, "gimp-palette-editor"); if (info && info->widget) { GimpPaletteEditor *editor; gint index; editor = GIMP_PALETTE_EDITOR (gtk_bin_get_child (GTK_BIN (info->widget))); index = gimp_palette_editor_get_index (editor, color); if (index != -1) gimp_palette_editor_set_index (editor, index, NULL); } } } switch (color_tool->pick_mode) { case GIMP_COLOR_PICK_MODE_NONE: break; case GIMP_COLOR_PICK_MODE_FOREGROUND: gimp_context_set_foreground (context, color); break; case GIMP_COLOR_PICK_MODE_BACKGROUND: gimp_context_set_background (context, color); break; case GIMP_COLOR_PICK_MODE_PALETTE: { GdkScreen *screen; GtkWidget *dockable; screen = gtk_widget_get_screen (tool->display->shell); dockable = gimp_dialog_factory_dialog_raise (dialog_factory, screen, "gimp-palette-editor", -1); if (dockable) { GtkWidget *palette_editor; GimpData *data; /* don't blink like mad when updating */ if (pick_state == GIMP_COLOR_PICK_STATE_UPDATE) gimp_dockable_blink_cancel (GIMP_DOCKABLE (dockable)); palette_editor = gtk_bin_get_child (GTK_BIN (dockable)); data = gimp_data_editor_get_data (GIMP_DATA_EDITOR (palette_editor)); if (! data) { data = GIMP_DATA (gimp_context_get_palette (context)); gimp_data_editor_set_data (GIMP_DATA_EDITOR (palette_editor), data); } gimp_palette_editor_pick_color (GIMP_PALETTE_EDITOR (palette_editor), color, pick_state); } } break; } }
void gimp_display_shell_update_cursor (GimpDisplayShell *shell, gint display_x, gint display_y, gint image_x, gint image_y) { GimpDialogFactory *factory; GimpSessionInfo *session_info; GimpImage *image; gboolean new_cursor; g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell)); image = shell->display->image; new_cursor = (shell->draw_cursor && shell->proximity && display_x >= 0 && display_y >= 0); /* Erase old cursor, if necessary */ if (shell->have_cursor && (! new_cursor || display_x != shell->cursor_x || display_y != shell->cursor_y)) { gimp_display_shell_expose_area (shell, shell->cursor_x - 7, shell->cursor_y - 7, 15, 15); if (! new_cursor) shell->have_cursor = FALSE; } shell->have_cursor = new_cursor; shell->cursor_x = display_x; shell->cursor_y = display_y; /* use the passed image_coords for the statusbar because they are * possibly snapped... */ gimp_statusbar_update_cursor (GIMP_STATUSBAR (shell->statusbar), image_x, image_y); factory = gimp_dialog_factory_from_name ("dock"); session_info = gimp_dialog_factory_find_session_info (factory, "gimp-cursor-view"); if (session_info && session_info->widget) { GtkWidget *cursor_view; cursor_view = gtk_bin_get_child (GTK_BIN (session_info->widget)); if (cursor_view) { gint t_x = -1; gint t_y = -1; /* ...but use the unsnapped display_coords for the info window */ if (display_x >= 0 && display_y >= 0) gimp_display_shell_untransform_xy (shell, display_x, display_y, &t_x, &t_y, FALSE, FALSE); gimp_cursor_view_update_cursor (GIMP_CURSOR_VIEW (cursor_view), shell->display->image, shell->unit, t_x, t_y); } } }
static GtkWidget * gimp_dialog_factory_dialog_new_internal (GimpDialogFactory *factory, GdkScreen *screen, GimpContext *context, const gchar *identifier, gint view_size, gboolean return_existing, gboolean present) { GimpDialogFactoryEntry *entry; GtkWidget *dialog = NULL; g_return_val_if_fail (GIMP_IS_DIALOG_FACTORY (factory), NULL); g_return_val_if_fail (identifier != NULL, NULL); entry = gimp_dialog_factory_find_entry (factory, identifier); if (! entry) { g_warning ("%s: no entry registered for \"%s\"", G_STRFUNC, identifier); return NULL; } if (! entry->new_func) { g_warning ("%s: entry for \"%s\" has no constructor", G_STRFUNC, identifier); return NULL; } /* a singleton dialog is always returned if it already exisits */ if (return_existing || entry->singleton) { GimpSessionInfo *info; info = gimp_dialog_factory_find_session_info (factory, identifier); if (info) dialog = info->widget; } /* create the dialog if it was not found */ if (! dialog) { GtkWidget *dock = NULL; /* If the dialog will be a dockable (factory->new_dock_func) and * we are called from gimp_dialog_factory_dialog_raise() (! context), * create a new dock _before_ creating the dialog. * We do this because the new dockable needs to be created in it's * dock's context. */ if (factory->new_dock_func && ! context) { GtkWidget *dockbook; dock = gimp_dialog_factory_dock_new (factory, screen); dockbook = gimp_dockbook_new (factory->menu_factory); gimp_dock_add_book (GIMP_DOCK (dock), GIMP_DOCKBOOK (dockbook), 0); } /* Create the new dialog in the appropriate context which is * - the passed context if not NULL * - the newly created dock's context if we just created it * - the factory's context, which happens when raising a toplevel * dialog was the original request. */ if (view_size < GIMP_VIEW_SIZE_TINY) view_size = entry->view_size; if (context) dialog = factory->constructor (factory, entry, context, view_size); else if (dock) dialog = factory->constructor (factory, entry, GIMP_DOCK (dock)->context, view_size); else dialog = factory->constructor (factory, entry, factory->context, view_size); if (dialog) { gimp_dialog_factory_set_widget_data (dialog, factory, entry); /* If we created a dock before, the newly created dialog is * supposed to be a GimpDockable. */ if (dock) { if (GIMP_IS_DOCKABLE (dialog)) { gimp_dock_add (GIMP_DOCK (dock), GIMP_DOCKABLE (dialog), 0, 0); gtk_widget_show (dock); } else { g_warning ("%s: GimpDialogFactory is a dockable factory " "but constructor for \"%s\" did not return a " "GimpDockable", G_STRFUNC, identifier); gtk_widget_destroy (dialog); gtk_widget_destroy (dock); dialog = NULL; dock = NULL; } } } else if (dock) { g_warning ("%s: constructor for \"%s\" returned NULL", G_STRFUNC, identifier); gtk_widget_destroy (dock); dock = NULL; } if (dialog) gimp_dialog_factory_add_dialog (factory, dialog); } /* Finally, if we found an existing dialog or created a new one, raise it. */ if (! dialog) return NULL; if (GTK_WIDGET_TOPLEVEL (dialog)) { gtk_window_set_screen (GTK_WINDOW (dialog), screen); if (present) gtk_window_present (GTK_WINDOW (dialog)); } else if (GIMP_IS_DOCKABLE (dialog)) { GimpDockable *dockable = GIMP_DOCKABLE (dialog); if (dockable->dockbook && dockable->dockbook->dock) { GtkNotebook *notebook = GTK_NOTEBOOK (dockable->dockbook); gint num = gtk_notebook_page_num (notebook, dialog); if (num != -1) { gtk_notebook_set_current_page (notebook, num); gimp_dockable_blink (dockable); } } if (present) { GtkWidget *toplevel = gtk_widget_get_toplevel (dialog); if (GTK_IS_WINDOW (toplevel)) gtk_window_present (GTK_WINDOW (toplevel)); } } return dialog; }