自学教程：C++ GIMP_IS_GIMP函数代码示例

voidtool_manager_oper_update_active (Gimp             *gimp,                                 const GimpCoords *coords,                                 GdkModifierType   state,                                 gboolean          proximity,                                 GimpDisplay      *display){  GimpToolManager *tool_manager;  g_return_if_fail (GIMP_IS_GIMP (gimp));  tool_manager = tool_manager_get (gimp);  if (tool_manager->active_tool)    {      gimp_tool_oper_update (tool_manager->active_tool,                             coords, state, proximity,                             display);    }}

GimpImage *gimp_edit_paste_as_new_image (Gimp       *gimp,                              GimpObject *paste){  GimpImage *image = NULL;  g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);  g_return_val_if_fail (GIMP_IS_IMAGE (paste) || GIMP_IS_BUFFER (paste), NULL);  if (GIMP_IS_IMAGE (paste))    {      image = gimp_image_duplicate (GIMP_IMAGE (paste));    }  else if (GIMP_IS_BUFFER (paste))    {      image = gimp_image_new_from_buffer (gimp, GIMP_BUFFER (paste));    }  return image;}

gbooleantool_manager_key_release_active (Gimp        *gimp,                                 GdkEventKey *kevent,                                 GimpDisplay *display){  GimpToolManager *tool_manager;  g_return_val_if_fail (GIMP_IS_GIMP (gimp), FALSE);  tool_manager = tool_manager_get (gimp);  if (tool_manager->active_tool)    {      return gimp_tool_key_release (tool_manager->active_tool,                                    kevent,                                    display);    }  return FALSE;}

voidgimp_filter_history_remove (Gimp          *gimp,                            GimpProcedure *procedure){  GList *link;  g_return_if_fail (GIMP_IS_GIMP (gimp));  g_return_if_fail (GIMP_IS_PROCEDURE (procedure));  link = g_list_find_custom (gimp->filter_history, procedure,                             (GCompareFunc) gimp_filter_history_compare);  if (link)    {      g_object_unref (link->data);      gimp->filter_history = g_list_delete_link (gimp->filter_history, link);      gimp_filter_history_changed (gimp);    }}

voidtool_manager_cursor_update_active (Gimp             *gimp,                                   const GimpCoords *coords,                                   GdkModifierType   state,                                   GimpDisplay      *display){  GimpToolManager *tool_manager;  g_return_if_fail (GIMP_IS_GIMP (gimp));  tool_manager = tool_manager_get (gimp);  if (tool_manager->active_tool &&      ! gimp_tool_control_is_active (tool_manager->active_tool->control))    {      gimp_tool_cursor_update (tool_manager->active_tool,                               coords, state,                               display);    }}

GtkWidget *file_open_dialog_new (Gimp *gimp){  GtkWidget           *dialog;  g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);  dialog = gimp_open_dialog_new (gimp);  gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (dialog), TRUE);  gimp_file_dialog_load_state (GIMP_FILE_DIALOG (dialog),                               "gimp-file-open-dialog-state");  g_signal_connect (dialog, "response",                    G_CALLBACK (file_open_dialog_response),                    gimp);  return dialog;}

voidtool_manager_button_release_active (Gimp             *gimp,                                    const GimpCoords *coords,                                    guint32           time,                                    GdkModifierType   state,                                    GimpDisplay      *display){  GimpToolManager *tool_manager;  g_return_if_fail (GIMP_IS_GIMP (gimp));  tool_manager = tool_manager_get (gimp);  if (tool_manager->active_tool)    {      gimp_tool_button_release (tool_manager->active_tool,                                coords, time, state,                                display);    }}

voidgimp_set_global_buffer (Gimp       *gimp,                        GimpBuffer *buffer){  g_return_if_fail (GIMP_IS_GIMP (gimp));  g_return_if_fail (buffer == NULL || GIMP_IS_BUFFER (buffer));  if (buffer == gimp->global_buffer)    return;  if (gimp->global_buffer)    g_object_unref (gimp->global_buffer);  gimp->global_buffer = buffer;  if (gimp->global_buffer)    g_object_ref (gimp->global_buffer);  g_signal_emit (gimp, gimp_signals[BUFFER_CHANGED], 0);}

GimpDisplay *gimp_display_get_by_ID (Gimp *gimp,                        gint  ID){  GList *list;  g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);  for (list = GIMP_LIST (gimp->displays)->list;       list;       list = g_list_next (list))    {      GimpDisplay *display = list->data;      if (display->ID == ID)        return display;    }  return NULL;}

voiddialogs_exit (Gimp *gimp){  g_return_if_fail (GIMP_IS_GIMP (gimp));  if (global_dialog_factory)    {      g_object_unref (global_dialog_factory);      global_dialog_factory = NULL;    }  /*  destroy the "global_toolbox_factory" _before_ destroying the   *  "global_dock_factory" because the "global_toolbox_factory" owns   *  dockables which were created by the "global_dock_factory".  This   *  way they are properly removed from the "global_dock_factory", which   *  would complain about stale entries otherwise.   */  if (global_toolbox_factory)    {      g_object_unref (global_toolbox_factory);      global_toolbox_factory = NULL;    }  if (global_dock_factory)    {      g_object_unref (global_dock_factory);      global_dock_factory = NULL;    }  if (global_display_factory)    {      g_object_unref (global_display_factory);      global_display_factory = NULL;    }  if (global_recent_docks)    {      g_object_unref (global_recent_docks);      global_recent_docks = NULL;    }}

voidtool_manager_init (Gimp *gimp){  GimpToolManager *tool_manager;  GimpContext     *user_context;  g_return_if_fail (GIMP_IS_GIMP (gimp));  tool_manager = g_slice_new0 (GimpToolManager);  tool_manager->active_tool            = NULL;  tool_manager->tool_stack             = NULL;  tool_manager->image_clean_handler_id = 0;  tool_manager->image_dirty_handler_id = 0;  tool_manager_set (gimp, tool_manager);  tool_manager->image_clean_handler_id =    gimp_container_add_handler (gimp->images, "clean",                                G_CALLBACK (tool_manager_image_clean_dirty),                                tool_manager);  tool_manager->image_dirty_handler_id =    gimp_container_add_handler (gimp->images, "dirty",                                G_CALLBACK (tool_manager_image_clean_dirty),                                tool_manager);  user_context = gimp_get_user_context (gimp);  tool_manager->shared_paint_options = g_object_new (GIMP_TYPE_PAINT_OPTIONS,                                                     "gimp", gimp,                                                     "name", "tmp",                                                     NULL);  g_signal_connect (user_context, "tool-changed",                    G_CALLBACK (tool_manager_tool_changed),                    tool_manager);  g_signal_connect (user_context, "tool-preset-changed",                    G_CALLBACK (tool_manager_preset_changed),                    tool_manager);}

voidtool_manager_pop_tool (Gimp *gimp){  GimpToolManager *tool_manager;  g_return_if_fail (GIMP_IS_GIMP (gimp));  tool_manager = tool_manager_get (gimp);  if (tool_manager->tool_stack)    {      GimpTool *tool = tool_manager->tool_stack->data;      tool_manager->tool_stack = g_slist_remove (tool_manager->tool_stack,                                                 tool);      tool_manager_select_tool (gimp, tool);      g_object_unref (tool);    }}

voidgimp_contexts_init (Gimp *gimp){  GimpContext *context;  g_return_if_fail (GIMP_IS_GIMP (gimp));  /*  the default context contains the user's saved preferences   *   *  TODO: load from disk   */  context = gimp_context_new (gimp, "Default", NULL);  gimp_set_default_context (gimp, context);  g_object_unref (context);  /*  the initial user_context is a straight copy of the default context   */  context = gimp_context_new (gimp, "User", context);  gimp_set_user_context (gimp, context);  g_object_unref (context);}

gbooleangimp_progress_message (GimpProgress        *progress,                       Gimp                *gimp,                       GimpMessageSeverity  severity,                       const gchar         *domain,                       const gchar         *message){  GimpProgressInterface *progress_iface;  g_return_val_if_fail (GIMP_IS_PROGRESS (progress), FALSE);  g_return_val_if_fail (GIMP_IS_GIMP (gimp), FALSE);  g_return_val_if_fail (domain != NULL, FALSE);  g_return_val_if_fail (message != NULL, FALSE);  progress_iface = GIMP_PROGRESS_GET_INTERFACE (progress);  if (progress_iface->message)    return progress_iface->message (progress, gimp, severity, domain, message);  return FALSE;}

GtkWidget *gimp_error_console_new (Gimp            *gimp,                        GimpMenuFactory *menu_factory){  GimpErrorConsole *console;  g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);  g_return_val_if_fail (GIMP_IS_MENU_FACTORY (menu_factory), NULL);  console = g_object_new (GIMP_TYPE_ERROR_CONSOLE,                          "menu-factory",   menu_factory,                          "menu-identifier", "<ErrorConsole>",                          "ui-path",        "/error-console-popup",                          NULL);  console->gimp = gimp;  console->gimp->message_handler = GIMP_ERROR_CONSOLE;  return GTK_WIDGET (console);}

voidmenus_save (Gimp     *gimp,            gboolean  always_save){  gchar *filename;  g_return_if_fail (GIMP_IS_GIMP (gimp));  if (menurc_deleted && ! always_save)    return;  filename = gimp_personal_rc_file ("menurc");  if (gimp->be_verbose)    g_print ("Writing '%s'/n", gimp_filename_to_utf8 (filename));  gtk_accel_map_save (filename);  g_free (filename);  menurc_deleted = FALSE;}

/** * gimp_clipboard_set_text: * @gimp: pointer to #Gimp * @text: a %NULL-terminated string in UTF-8 encoding * * Offers @text in %GDK_SELECTION_CLIPBOARD and %GDK_SELECTION_PRIMARY. **/voidgimp_clipboard_set_text (Gimp        *gimp,                         const gchar *text){  GtkClipboard *clipboard;  g_return_if_fail (GIMP_IS_GIMP (gimp));  g_return_if_fail (text != NULL);  gimp_clipboard_clear (gimp_clipboard_get (gimp));  clipboard = gtk_clipboard_get_for_display (gdk_display_get_default (),                                             GDK_SELECTION_CLIPBOARD);  if (clipboard)    gtk_clipboard_set_text (clipboard, text, -1);  clipboard = gtk_clipboard_get_for_display (gdk_display_get_default (),                                             GDK_SELECTION_PRIMARY);  if (clipboard)    gtk_clipboard_set_text (clipboard, text, -1);}

GtkWidget *gimp_export_dialog_new (Gimp *gimp){  g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);  return g_object_new (GIMP_TYPE_EXPORT_DIALOG,                       "gimp",                  gimp,                       "title",                 _("Export Image"),                       "role",                  "gimp-file-export",                       "help-id",               GIMP_HELP_FILE_EXPORT_AS,                       "ok-button-label",       _("_Export"),                       "automatic-label",       _("By Extension"),                       "automatic-help-id",     GIMP_HELP_FILE_SAVE_BY_EXTENSION,                       "action",                GTK_FILE_CHOOSER_ACTION_SAVE,                       "file-procs",            GIMP_FILE_PROCEDURE_GROUP_EXPORT,                       "file-procs-all-images", GIMP_FILE_PROCEDURE_GROUP_SAVE,                       "file-filter-label",     _("All export images"),                       NULL);}

voiddialogs_exit (Gimp *gimp){  g_return_if_fail (GIMP_IS_GIMP (gimp));  if (gimp_dialog_factory_get_singleton ())    {      /* run dispose manually so the factory destroys its dialogs, which       * might in turn directly or indirectly ref the factory       */      g_object_run_dispose (G_OBJECT (gimp_dialog_factory_get_singleton ()));      g_object_unref (gimp_dialog_factory_get_singleton ());      gimp_dialog_factory_set_singleton (NULL);    }  if (global_recent_docks)    {      g_object_unref (global_recent_docks);      global_recent_docks = NULL;    }}

voidgimp_wait (Gimp         *gimp,           GimpWaitable *waitable,           const gchar  *format,           ...){  va_list  args;  gchar   *message;  g_return_if_fail (GIMP_IS_GIMP (gimp));  g_return_if_fail (GIMP_IS_WAITABLE (waitable));  g_return_if_fail (format != NULL);  if (gimp_waitable_wait_for (waitable, 0.5 * G_TIME_SPAN_SECOND))    return;  va_start (args, format);  message = g_strdup_vprintf (format, args);  va_end (args);  if (! gimp->console_messages &&      gimp->gui.wait           &&      gimp->gui.wait (gimp, waitable, message))    {      return;    }  /* Translator:  This message is displayed while GIMP is waiting for   * some operation to finish.  The %s argument is a message describing   * the operation.   */  g_printerr (_("Please wait: %s/n"), message);  gimp_waitable_wait (waitable);  g_free (message);}

GimpColorProfilePolicygimp_query_profile_policy (Gimp                      *gimp,                           GimpImage                 *image,                           GimpContext               *context,                           GimpColorProfile         **dest_profile,                           GimpColorRenderingIntent  *intent,                           gboolean                  *bpc,                           gboolean                  *dont_ask){  g_return_val_if_fail (GIMP_IS_GIMP (gimp), GIMP_COLOR_PROFILE_POLICY_KEEP);  g_return_val_if_fail (GIMP_IS_IMAGE (image), GIMP_COLOR_PROFILE_POLICY_KEEP);  g_return_val_if_fail (GIMP_IS_CONTEXT (context), GIMP_COLOR_PROFILE_POLICY_KEEP);  g_return_val_if_fail (dest_profile != NULL, GIMP_COLOR_PROFILE_POLICY_KEEP);  if (gimp->gui.query_profile_policy)    return gimp->gui.query_profile_policy (gimp, image, context,                                           dest_profile,                                           intent, bpc,                                           dont_ask);  return GIMP_COLOR_PROFILE_POLICY_KEEP;}

/** * gimp_clipboard_has_svg: * @gimp: pointer to #Gimp * * Tests if there's SVG data in %GDK_SELECTION_CLIPBOARD. * This is done in a main-loop similar to * gtk_clipboard_wait_is_text_available(). The same caveats apply here. * * Return value: %TRUE if there's SVG data in the clipboard, %FALSE otherwise **/gbooleangimp_clipboard_has_svg (Gimp *gimp){  GimpClipboard *gimp_clip;  GtkClipboard  *clipboard;  g_return_val_if_fail (GIMP_IS_GIMP (gimp), FALSE);  clipboard = gtk_clipboard_get_for_display (gdk_display_get_default (),                                             GDK_SELECTION_CLIPBOARD);  if (clipboard                                              &&      gtk_clipboard_get_owner (clipboard) != G_OBJECT (gimp) &&      gimp_clipboard_wait_for_svg (gimp)  != GDK_NONE)    {      return TRUE;    }  gimp_clip = gimp_clipboard_get (gimp);  return (gimp_clip->svg != NULL);}

voidthemes_init (Gimp *gimp){  GimpGuiConfig *config;  gchar         *themerc;  g_return_if_fail (GIMP_IS_GIMP (gimp));  config = GIMP_GUI_CONFIG (gimp->config);  themes_hash = g_hash_table_new_full (g_str_hash,                                       g_str_equal,                                       g_free,                                       g_free);  if (config->theme_path)    {      gchar *path;      path = gimp_config_path_expand (config->theme_path, TRUE, NULL);      gimp_datafiles_read_directories (path,                                       G_FILE_TEST_IS_DIR,                                       themes_directories_foreach,                                       gimp);      g_free (path);    }  themes_apply_theme (gimp, config->theme);  themerc = gimp_personal_rc_file ("themerc");  gtk_rc_parse (themerc);  g_free (themerc);  g_signal_connect (config, "notify::theme",                    G_CALLBACK (themes_theme_change_notify),                    gimp);}

voidgimp_load_config (Gimp  *gimp,                  GFile *alternate_system_gimprc,                  GFile *alternate_gimprc){  GimpRc *gimprc;  g_return_if_fail (GIMP_IS_GIMP (gimp));  g_return_if_fail (alternate_system_gimprc == NULL ||                    G_IS_FILE (alternate_system_gimprc));  g_return_if_fail (alternate_gimprc == NULL ||                    G_IS_FILE (alternate_gimprc));  g_return_if_fail (gimp->config == NULL);  g_return_if_fail (gimp->edit_config == NULL);  if (gimp->be_verbose)    g_print ("INIT: %s/n", G_STRFUNC);  /*  this needs to be done before gimprc loading because gimprc can   *  use user defined units   */  gimp_unitrc_load (gimp);  gimprc = gimp_rc_new (alternate_system_gimprc,                        alternate_gimprc,                        gimp->be_verbose);  gimp->config = GIMP_CORE_CONFIG (gimprc);  gimp->edit_config = gimp_config_duplicate (GIMP_CONFIG (gimp->config));  g_signal_connect_object (gimp->config, "notify",                           G_CALLBACK (gimp_global_config_notify),                           gimp->edit_config, 0);  g_signal_connect_object (gimp->edit_config, "notify",                           G_CALLBACK (gimp_edit_config_notify),                           gimp->config, 0);}

voidthemes_init (Gimp *gimp){  GimpGuiConfig *config;  g_return_if_fail (GIMP_IS_GIMP (gimp));  config = GIMP_GUI_CONFIG (gimp->config);  /* Check for theme extensions. */  themes_theme_paths_notify (gimp->extension_manager, NULL, gimp);  g_signal_connect (gimp->extension_manager, "notify::theme-paths",                    G_CALLBACK (themes_theme_paths_notify),                    gimp);  themes_style_provider = GTK_STYLE_PROVIDER (gtk_css_provider_new ());  /*  Use GTK_STYLE_PROVIDER_PRIORITY_APPLICATION + 1 so theme files   *  override default styles provided by widgets themselves.   */  gtk_style_context_add_provider_for_screen (gdk_screen_get_default (),                                             themes_style_provider,                                             GTK_STYLE_PROVIDER_PRIORITY_APPLICATION + 1);  g_object_unref (themes_style_provider);  g_signal_connect (config, "notify::theme",                    G_CALLBACK (themes_theme_change_notify),                    gimp);  g_signal_connect (config, "notify::prefer-dark-theme",                    G_CALLBACK (themes_theme_change_notify),                    gimp);  g_signal_connect (config, "notify::prefer-symbolic-icons",                    G_CALLBACK (themes_theme_change_notify),                    gimp);  themes_theme_change_notify (config, NULL, gimp);}

/** * gimp_clipboard_set_buffer: * @gimp:   pointer to #Gimp * @buffer: a #GimpBuffer, or %NULL. * * Offers the buffer in %GDK_SELECTION_CLIPBOARD. **/voidgimp_clipboard_set_buffer (Gimp       *gimp,                           GimpBuffer *buffer){  GimpClipboard *gimp_clip;  GtkClipboard  *clipboard;  g_return_if_fail (GIMP_IS_GIMP (gimp));  g_return_if_fail (buffer == NULL || GIMP_IS_BUFFER (buffer));  clipboard = gtk_clipboard_get_for_display (gdk_display_get_default (),                                             GDK_SELECTION_CLIPBOARD);  if (! clipboard)    return;  gimp_clip = gimp_clipboard_get (gimp);  gimp_clipboard_clear (gimp_clip);  if (buffer)    {      gimp_clip->buffer = g_object_ref (buffer);      gtk_clipboard_set_with_owner (clipboard,                                    gimp_clip->target_entries,                                    gimp_clip->n_target_entries,                                    (GtkClipboardGetFunc) gimp_clipboard_send_buffer,                                    (GtkClipboardClearFunc) NULL,                                    G_OBJECT (gimp));      /*  mark the first entry (image/png) as suitable for storing  */      gtk_clipboard_set_can_store (clipboard, gimp_clip->target_entries, 1);    }  else if (gtk_clipboard_get_owner (clipboard) == G_OBJECT (gimp))    {      gtk_clipboard_clear (clipboard);    }}

voidgimp_filter_history_add (Gimp          *gimp,                         GimpProcedure *procedure){  GList *link;  g_return_if_fail (GIMP_IS_GIMP (gimp));  g_return_if_fail (GIMP_IS_PROCEDURE (procedure));  /* return early if the procedure is already at the top */  if (gimp->filter_history &&      gimp_filter_history_compare (gimp->filter_history->data, procedure) == 0)    return;  /* ref new first then unref old, they might be the same */  g_object_ref (procedure);  link = g_list_find_custom (gimp->filter_history, procedure,                             (GCompareFunc) gimp_filter_history_compare);  if (link)    {      g_object_unref (link->data);      gimp->filter_history = g_list_delete_link (gimp->filter_history, link);    }  gimp->filter_history = g_list_prepend (gimp->filter_history, procedure);  link = g_list_nth (gimp->filter_history, gimp_filter_history_size (gimp));  if (link)    {      g_object_unref (link->data);      gimp->filter_history = g_list_delete_link (gimp->filter_history, link);    }  gimp_filter_history_changed (gimp);}

GtkWidget *input_devices_dialog_new (Gimp *gimp){  GtkWidget *dialog;  GtkWidget *content_area;  GtkWidget *editor;  g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);  dialog = gimp_dialog_new (_("Configure Input Devices"),                            "gimp-input-devices-dialog",                            NULL, 0,                            gimp_standard_help_func,                            GIMP_HELP_INPUT_DEVICES,                            GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,                            GTK_STOCK_SAVE,  GTK_RESPONSE_OK,                            NULL);  gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),                                           GTK_RESPONSE_OK,                                           GTK_RESPONSE_CLOSE,                                           -1);  g_signal_connect (dialog, "response",                    G_CALLBACK (input_devices_dialog_response),                    gimp);  content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));  editor = gimp_device_editor_new (gimp);  gtk_container_set_border_width (GTK_CONTAINER (editor), 12);  gtk_box_pack_start (GTK_BOX (content_area), editor, TRUE, TRUE, 0);  gtk_widget_show (editor);  return dialog;}

/* Search all history actions which match "keyword" with function * match_func(action, keyword). * * @return a list of GtkAction*, to free with: * g_list_free_full (result, (GDestroyNotify) g_object_unref); */GList *gimp_action_history_search (Gimp                *gimp,                            GimpActionMatchFunc  match_func,                            const gchar         *keyword){  GimpGuiConfig *config;  GimpUIManager *manager;  GList         *actions;  GList         *result = NULL;  gint           i;  g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);  g_return_val_if_fail (match_func != NULL, NULL);  config  = GIMP_GUI_CONFIG (gimp->config);  manager = gimp_ui_managers_from_name ("<Image>")->data;  for (actions = history.items, i = 0;       actions && i < config->action_history_size;       actions = g_list_next (actions), i++)    {      GimpActionHistoryItem *item   = actions->data;      GtkAction             *action;      action = gimp_ui_manager_find_action (manager, NULL, item->action_name);      if (action == NULL)        continue;      if (! gtk_action_is_sensitive (action) &&          ! config->search_show_unavailable)        continue;      if (match_func (action, keyword, NULL, gimp))        result = g_list_prepend (result, g_object_ref (action));    }  return g_list_reverse (result);}