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

static guint32gimp_display_progress_get_window (GimpProgress *progress){  GimpDisplay *display = GIMP_DISPLAY (progress);  if (display->shell)    return gimp_progress_get_window (GIMP_PROGRESS (display->shell));  return 0;}

static gdoublegimp_tool_progress_get_value (GimpProgress *progress){  GimpTool *tool = GIMP_TOOL (progress);  if (tool->progress)    return gimp_progress_get_value (GIMP_PROGRESS (tool->progress));  return 0.0;}

static gdoublegimp_display_progress_get_value (GimpProgress *progress){  GimpDisplay *display = GIMP_DISPLAY (progress);  if (display->shell)    return gimp_progress_get_value (GIMP_PROGRESS (display->shell));  return 0.0;}

static gbooleangimp_display_progress_is_active (GimpProgress *progress){  GimpDisplay *display = GIMP_DISPLAY (progress);  if (display->shell)    return gimp_progress_is_active (GIMP_PROGRESS (display->shell));  return FALSE;}

/*  This function is called for filenames passed on the command-line *  or from the D-Bus service. */gbooleanfile_open_from_command_line (Gimp     *gimp,                             GFile    *file,                             gboolean  as_new,                             GObject  *screen,                             gint      monitor){  GimpImage         *image;  GimpObject        *display;  GimpPDBStatusType  status;  gboolean           success = FALSE;  GError            *error   = NULL;  g_return_val_if_fail (GIMP_IS_GIMP (gimp), FALSE);  g_return_val_if_fail (G_IS_FILE (file), FALSE);  g_return_val_if_fail (screen == NULL || G_IS_OBJECT (screen), FALSE);  display = gimp_get_empty_display (gimp);  /* show the progress in the last opened display, see bug #704896 */  if (! display)    display = gimp_context_get_display (gimp_get_user_context (gimp));  if (display)    g_object_add_weak_pointer (G_OBJECT (display), (gpointer) &display);  image = file_open_with_display (gimp,                                  gimp_get_user_context (gimp),                                  GIMP_PROGRESS (display),                                  file, as_new,                                  screen, monitor,                                  &status, &error);  if (image)    {      success = TRUE;      g_object_set_data_full (G_OBJECT (gimp), GIMP_FILE_OPEN_LAST_FILE_KEY,                              g_object_ref (file),                              (GDestroyNotify) g_object_unref);    }  else if (status != GIMP_PDB_CANCEL && display)    {      gimp_message (gimp, G_OBJECT (display), GIMP_MESSAGE_ERROR,                    _("Opening '%s' failed: %s"),                    gimp_file_get_utf8_name (file), error->message);      g_clear_error (&error);    }  if (display)    g_object_remove_weak_pointer (G_OBJECT (display), (gpointer) &display);  return success;}

voidfile_open_recent_cmd_callback (GtkAction *action,                               gint       value,                               gpointer   data){  Gimp          *gimp;  GimpImagefile *imagefile;  gint           num_entries;  return_if_no_gimp (gimp, data);  num_entries = gimp_container_get_n_children (gimp->documents);  if (value >= num_entries)    return;  imagefile = (GimpImagefile *)    gimp_container_get_child_by_index (gimp->documents, value);  if (imagefile)    {      GimpDisplay       *display;      GimpProgress      *progress;      GimpImage         *image;      GimpPDBStatusType  status;      GError            *error = NULL;      return_if_no_display (display, data);      g_object_ref (display);      g_object_ref (imagefile);      progress = gimp_display_get_image (display) ?                 NULL : GIMP_PROGRESS (display);      image = file_open_with_display (gimp, action_data_get_context (data),                                      progress,                                      gimp_object_get_name (imagefile), FALSE,                                      &status, &error);      if (! image && status != GIMP_PDB_CANCEL)        {          gchar *filename =            file_utils_uri_display_name (gimp_object_get_name (imagefile));          gimp_message (gimp, G_OBJECT (display), GIMP_MESSAGE_ERROR,                        _("Opening '%s' failed:/n/n%s"),                        filename, error->message);          g_clear_error (&error);          g_free (filename);        }      g_object_unref (imagefile);      g_object_unref (display);    }}

static gbooleangimp_thumb_box_auto_thumbnail (GimpThumbBox *box){  Gimp          *gimp  = box->imagefile->gimp;  GimpThumbnail *thumb = box->imagefile->thumbnail;  const gchar   *uri   = gimp_object_get_name (GIMP_OBJECT (box->imagefile));  box->idle_id = 0;  if (thumb->image_state == GIMP_THUMB_STATE_NOT_FOUND)    return FALSE;  switch (thumb->thumb_state)    {    case GIMP_THUMB_STATE_NOT_FOUND:    case GIMP_THUMB_STATE_OLD:      if (thumb->image_filesize < gimp->config->thumbnail_filesize_limit &&          ! gimp_thumbnail_has_failed (thumb)                            &&          file_procedure_find_by_extension (gimp->plug_in_manager->load_procs,                                            uri))        {          if (thumb->image_filesize > 0)            {              gchar *size;              gchar *text;              size = gimp_memsize_to_string (thumb->image_filesize);              text = g_strdup_printf ("%s/n%s",                                      size, _("Creating preview..."));              gtk_label_set_text (GTK_LABEL (box->info), text);              g_free (text);              g_free (size);            }          else            {              gtk_label_set_text (GTK_LABEL (box->info),                                  _("Creating preview..."));            }          gimp_imagefile_create_thumbnail_weak (box->imagefile, box->context,                                                GIMP_PROGRESS (box),                                                gimp->config->thumbnail_size,                                                TRUE);        }      break;    default:      break;    }  return FALSE;}

voidhelp_help_cmd_callback (GtkAction *action,                        gpointer   data){  Gimp        *gimp;  GimpDisplay *display;  return_if_no_gimp (gimp, data);  return_if_no_display (display, data);  gimp_help_show (gimp, GIMP_PROGRESS (display), NULL, NULL);}

static voidgimp_progress_dialog_progress_set_text (GimpProgress *progress,                                        const gchar  *message){  GimpProgressDialog *dialog = GIMP_PROGRESS_DIALOG (progress);  if (! dialog->box)    return;  gimp_progress_set_text (GIMP_PROGRESS (dialog->box), message);}

static voidgimp_progress_dialog_progress_set_value (GimpProgress *progress,                                         gdouble       percentage){  GimpProgressDialog *dialog = GIMP_PROGRESS_DIALOG (progress);  if (! dialog->box)    return;  gimp_progress_set_value (GIMP_PROGRESS (dialog->box), percentage);}

voidvectors_selection_to_vectors_cmd_callback (GtkAction *action,                                           gint       value,                                           gpointer   data){  GimpImage      *image;  GtkWidget      *widget;  GimpProcedure  *procedure;  GimpValueArray *args;  GimpDisplay    *display;  GError         *error = NULL;  return_if_no_image (image, data);  return_if_no_widget (widget, data);  if (value)    procedure = gimp_pdb_lookup_procedure (image->gimp->pdb,                                           "plug-in-sel2path-advanced");  else    procedure = gimp_pdb_lookup_procedure (image->gimp->pdb,                                           "plug-in-sel2path");  if (! procedure)    {      gimp_message_literal (image->gimp,                            G_OBJECT (widget), GIMP_MESSAGE_ERROR,                            "Selection to path procedure lookup failed.");      return;    }  display = gimp_context_get_display (action_data_get_context (data));  args = gimp_procedure_get_arguments (procedure);  gimp_value_array_truncate (args, 2);  g_value_set_int      (gimp_value_array_index (args, 0),                        GIMP_RUN_INTERACTIVE);  gimp_value_set_image (gimp_value_array_index (args, 1),                        image);  gimp_procedure_execute_async (procedure, image->gimp,                                action_data_get_context (data),                                GIMP_PROGRESS (display), args,                                GIMP_OBJECT (display), &error);  gimp_value_array_unref (args);  if (error)    {      gimp_message_literal (image->gimp,                            G_OBJECT (widget), GIMP_MESSAGE_ERROR,                            error->message);      g_error_free (error);    }}

static gbooleangimp_tool_progress_key_press (GtkWidget         *widget,                              const GdkEventKey *kevent,                              GimpTool          *tool){  if (kevent->keyval == GDK_KEY_Escape)    {      gimp_progress_cancel (GIMP_PROGRESS (tool));    }  return TRUE;}

voidgimp_progress_update_and_flush (gint     min,                                gint     max,                                gint     current,                                gpointer data){  gimp_progress_set_value (GIMP_PROGRESS (data),                           (gdouble) (current - min) / (gdouble) (max - min));  while (g_main_context_pending (NULL))    g_main_context_iteration (NULL, TRUE);}

static voidgimp_cage_tool_create_render_node (GimpCageTool *ct){  GimpCageOptions *options  = GIMP_CAGE_TOOL_GET_OPTIONS (ct);  GeglNode        *coef, *cage, *render; /* Render nodes */  GeglNode        *input, *output; /* Proxy nodes*/  GeglNode        *node; /* wraper to be returned */  g_return_if_fail (ct->render_node == NULL);  /* render_node is not supposed to be recreated */  node = gegl_node_new ();  input  = gegl_node_get_input_proxy  (node, "input");  output = gegl_node_get_output_proxy (node, "output");  coef = gegl_node_new_child (node,                              "operation", "gegl:buffer-source",                              "buffer",    ct->coef,                              NULL);  cage = gegl_node_new_child (node,                              "operation",        "gimp:cage-transform",                              "config",           ct->config,                              "fill_plain_color", options->fill_plain_color,                              NULL);  render = gegl_node_new_child (node,                                "operation", "gegl:map-absolute",                                NULL);  gegl_node_connect_to (input, "output",                        cage, "input");  gegl_node_connect_to (coef, "output",                        cage, "aux");  gegl_node_connect_to (input, "output",                        render, "input");  gegl_node_connect_to (cage, "output",                        render, "aux");  gegl_node_connect_to (render, "output",                        output, "input");  ct->render_node = node;  ct->cage_node = cage;  ct->coef_node = coef;  gimp_gegl_progress_connect (cage, GIMP_PROGRESS (ct), _("Cage Transform"));}

/** * gimp_sub_progress_new: * @progress: parent progress or %NULL * * GimpSubProgress implements the GimpProgress interface and can be * used wherever a GimpProgress is needed. It maps progress * information to a sub-range of its parent @progress. This is useful * when an action breaks down into multiple sub-actions that itself * need a #GimpProgress pointer. See gimp_image_scale() for an example. * * Return value: a new #GimpProgress object */GimpProgress *gimp_sub_progress_new (GimpProgress *progress){  GimpSubProgress *sub;  g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), NULL);  sub = g_object_new (GIMP_TYPE_SUB_PROGRESS,                      "progress", progress,                      NULL);  return GIMP_PROGRESS (sub);}

static GimpProgress *gimp_display_progress_start (GimpProgress *progress,                             const gchar  *message,                             gboolean      cancelable){  GimpDisplay *display = GIMP_DISPLAY (progress);  if (display->shell)    return gimp_progress_start (GIMP_PROGRESS (display->shell),                                message, cancelable);  return NULL;}

static voidgimp_tool_progress_set_text (GimpProgress *progress,                             const gchar  *message){  GimpTool *tool = GIMP_TOOL (progress);  if (tool->progress)    {      GimpDisplayShell *shell = gimp_display_get_shell (tool->progress_display);      gimp_progress_set_text (GIMP_PROGRESS (tool->progress), message);      gimp_widget_flush_expose (shell->canvas);    }}

static voidgimp_tool_progress_set_value (GimpProgress *progress,                              gdouble       percentage){  GimpTool *tool = GIMP_TOOL (progress);  if (tool->progress)    {      GimpDisplayShell *shell = gimp_display_get_shell (tool->progress_display);      gimp_progress_set_value (GIMP_PROGRESS (tool->progress), percentage);      gimp_widget_flush_expose (shell->canvas);    }}

static gbooleangimp_display_progress_message (GimpProgress        *progress,                               Gimp                *gimp,                               GimpMessageSeverity  severity,                               const gchar         *domain,                               const gchar         *message){  GimpDisplay *display = GIMP_DISPLAY (progress);  if (display->shell)    return gimp_progress_message (GIMP_PROGRESS (display->shell), gimp,                                  severity, domain, message);  return FALSE;}

static voidgimp_blend_tool_commit (GimpBlendTool *blend_tool){  GimpTool *tool = GIMP_TOOL (blend_tool);  if (blend_tool->filter)    {      gimp_drawable_filter_commit (blend_tool->filter,                                   GIMP_PROGRESS (tool), FALSE);      g_object_unref (blend_tool->filter);      blend_tool->filter = NULL;      gimp_image_flush (gimp_display_get_image (tool->display));    }}

voiddrawable_value_invert_cmd_callback (GtkAction *action,                                    gpointer   data){  GimpImage    *image;  GimpDrawable *drawable;  GimpDisplay  *display;  return_if_no_drawable (image, drawable, data);  return_if_no_display (display, data);  gimp_drawable_apply_operation_by_name (drawable, GIMP_PROGRESS (display),                                         _("Invert"), "gegl:value-invert",                                         NULL);  gimp_image_flush (image);}

static gbooleangimp_seamless_clone_tool_key_press (GimpTool    *tool,                                    GdkEventKey *kevent,                                    GimpDisplay *display){  GimpSeamlessCloneTool *sct = GIMP_SEAMLESS_CLONE_TOOL (tool);  if (sct->tool_state == SC_STATE_RENDER_MOTION ||      sct->tool_state == SC_STATE_RENDER_WAIT)    {      switch (kevent->keyval)        {        case GDK_KEY_Return:        case GDK_KEY_KP_Enter:        case GDK_KEY_ISO_Enter:          gimp_tool_control_set_preserve (tool->control, TRUE);          /* TODO: there may be issues with committing the image map           *       result after some changes were made and the preview           *       was scrolled. We can fix these by either invalidating           *       the area which is a union of the previous paste           *       rectangle each time (in the update function) or by           *       invalidating and re-rendering all now (expensive and           *       perhaps useless */          gimp_image_map_commit (sct->image_map, GIMP_PROGRESS (tool));          g_object_unref (sct->image_map);          sct->image_map = NULL;          gimp_tool_control_set_preserve (tool->control, FALSE);          gimp_image_flush (gimp_display_get_image (display));          gimp_seamless_clone_tool_control (tool, GIMP_TOOL_ACTION_HALT,                                            display);          return TRUE;        case GDK_KEY_Escape:          gimp_seamless_clone_tool_control (tool, GIMP_TOOL_ACTION_HALT,                                            display);          return TRUE;        default:          break;        }    }  return FALSE;}

static voidimage_resize_callback (GtkWidget    *dialog,                       GimpViewable *viewable,                       gint          width,                       gint          height,                       GimpUnit      unit,                       gint          offset_x,                       gint          offset_y,                       GimpItemSet   layer_set,                       gpointer      data){  ImageResizeOptions *options = data;  image_resize_unit = unit;  if (width > 0 && height > 0)    {      GimpImage    *image   = GIMP_IMAGE (viewable);      GimpDisplay  *display = options->display;      GimpContext  *context = options->context;      GimpProgress *progress;      gtk_widget_destroy (dialog);      if (width  == gimp_image_get_width  (image) &&          height == gimp_image_get_height (image))        return;      progress = gimp_progress_start (GIMP_PROGRESS (display),                                      _("Resizing"), FALSE);      gimp_image_resize_with_layers (image,                                     context,                                     width, height, offset_x, offset_y,                                     layer_set,                                     progress);      if (progress)        gimp_progress_end (progress);      gimp_image_flush (image);    }  else    {      g_warning ("Resize Error: "                 "Both width and height must be greater than zero.");    }}

static voidgimp_cage_tool_commit (GimpCageTool *ct){  GimpTool *tool = GIMP_TOOL (ct);  gimp_tool_control_push_preserve (tool->control, TRUE);  gimp_image_map_commit (ct->image_map,                         GIMP_PROGRESS (tool));  g_object_unref (ct->image_map);  ct->image_map = NULL;  gimp_tool_control_pop_preserve (tool->control);  gimp_image_flush (gimp_display_get_image (tool->display));}

static voidgimp_tool_progress_end (GimpProgress *progress){  GimpTool *tool = GIMP_TOOL (progress);  if (tool->progress)    {      GimpDisplayShell *shell = gimp_display_get_shell (tool->progress_display);      gimp_progress_end (GIMP_PROGRESS (tool->progress));      gimp_display_shell_remove_item (shell, tool->progress);      tool->progress         = NULL;      tool->progress_display = NULL;    }}

static GimpProgress *gimp_tool_progress_start (GimpProgress *progress,                          const gchar  *message,                          gboolean      cancelable){  GimpTool         *tool = GIMP_TOOL (progress);  GimpDisplayShell *shell;  gint              x, y;  g_return_val_if_fail (GIMP_IS_DISPLAY (tool->display), NULL);  g_return_val_if_fail (tool->progress == NULL, NULL);  shell = gimp_display_get_shell (tool->display);  x = shell->disp_width  / 2;  y = shell->disp_height / 2;  gimp_display_shell_unzoom_xy (shell, x, y, &x, &y, FALSE);  tool->progress = gimp_canvas_progress_new (shell,                                             GIMP_HANDLE_ANCHOR_CENTER,                                             x, y);  gimp_display_shell_add_unrotated_item (shell, tool->progress);  g_object_unref (tool->progress);  gimp_progress_start (GIMP_PROGRESS (tool->progress),                       message, FALSE);  gimp_widget_flush_expose (shell->canvas);  tool->progress_display = tool->display;  if (cancelable)    {      tool->progress_grab_widget = gtk_invisible_new ();      gtk_widget_show (tool->progress_grab_widget);      gtk_grab_add (tool->progress_grab_widget);      g_signal_connect (tool->progress_grab_widget, "button-press-event",                        G_CALLBACK (gimp_tool_progress_button_press),                        tool);      g_signal_connect (tool->progress_grab_widget, "key-press-event",                        G_CALLBACK (gimp_tool_progress_key_press),                        tool);    }  return progress;}

static voidgimp_file_dialog_response (GtkDialog *dialog,                           gint       response_id){  GimpFileDialog *file_dialog = GIMP_FILE_DIALOG (dialog);  if (response_id != GTK_RESPONSE_OK && file_dialog->busy)    {      file_dialog->canceled = TRUE;      if (GIMP_PROGRESS_BOX (file_dialog->progress)->active &&          GIMP_PROGRESS_BOX (file_dialog->progress)->cancelable)        {          gimp_progress_cancel (GIMP_PROGRESS (dialog));        }    }}

static GimpProgress *gimp_file_dialog_progress_start (GimpProgress *progress,                                 const gchar  *message,                                 gboolean      cancelable){  GimpFileDialog *dialog = GIMP_FILE_DIALOG (progress);  GimpProgress   *retval;  retval = gimp_progress_start (GIMP_PROGRESS (dialog->progress),                                message, cancelable);  gtk_widget_show (dialog->progress);  gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog),                                     GTK_RESPONSE_CANCEL, cancelable);  return retval;}

static voidgimp_seamless_clone_tool_commit (GimpSeamlessCloneTool *sc){  GimpTool *tool = GIMP_TOOL (sc);  if (sc->filter)    {      gimp_tool_control_push_preserve (tool->control, TRUE);      gimp_drawable_filter_commit (sc->filter, GIMP_PROGRESS (tool), FALSE);      g_clear_object (&sc->filter);      gimp_tool_control_pop_preserve (tool->control);      gimp_image_flush (gimp_display_get_image (tool->display));    }}

static voidgimp_progress_dialog_progress_end (GimpProgress *progress){  GimpProgressDialog *dialog = GIMP_PROGRESS_DIALOG (progress);  if (! dialog->box)    return;  if (GIMP_PROGRESS_BOX (dialog->box)->active)    {      gimp_progress_end (GIMP_PROGRESS (dialog->box));      gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog),                                         GTK_RESPONSE_CANCEL, FALSE);      gtk_widget_hide (GTK_WIDGET (dialog));    }}