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

voidgimp_progress_pulse (GimpProgress *progress){  GimpProgressInterface *progress_iface;  g_return_if_fail (GIMP_IS_PROGRESS (progress));  progress_iface = GIMP_PROGRESS_GET_INTERFACE (progress);  if (progress_iface->pulse)    progress_iface->pulse (progress);}

GMountOperation *gimp_get_mount_operation (Gimp         *gimp,                          GimpProgress *progress){  g_return_val_if_fail (GIMP_IS_GIMP (gimp), FALSE);  g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), FALSE);  if (gimp->gui.get_mount_operation)    return gimp->gui.get_mount_operation (gimp, progress);  return g_mount_operation_new ();}

voidgimp_help (Gimp         *gimp,           GimpProgress *progress,           const gchar  *help_domain,           const gchar  *help_id){  g_return_if_fail (GIMP_IS_GIMP (gimp));  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));  if (gimp->gui.help)    gimp->gui.help (gimp, progress, help_domain, help_id);}

/** * 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);}

gdoublegimp_progress_get_value (GimpProgress *progress){  GimpProgressInterface *progress_iface;  g_return_val_if_fail (GIMP_IS_PROGRESS (progress), 0.0);  progress_iface = GIMP_PROGRESS_GET_INTERFACE (progress);  if (progress_iface->get_value)    return progress_iface->get_value (progress);  return 0.0;}

gbooleangimp_progress_is_active (GimpProgress *progress){  GimpProgressInterface *progress_iface;  g_return_val_if_fail (GIMP_IS_PROGRESS (progress), FALSE);  progress_iface = GIMP_PROGRESS_GET_INTERFACE (progress);  if (progress_iface->is_active)    return progress_iface->is_active (progress);  return FALSE;}

voidgimp_progress_set_text_literal (GimpProgress *progress,                                const gchar  *message){  GimpProgressInterface *progress_iface;  g_return_if_fail (GIMP_IS_PROGRESS (progress));  g_return_if_fail (message != NULL);  progress_iface = GIMP_PROGRESS_GET_INTERFACE (progress);  if (progress_iface->set_text)    progress_iface->set_text (progress, message);}

guint32gimp_progress_get_window_id (GimpProgress *progress){  GimpProgressInterface *progress_iface;  g_return_val_if_fail (GIMP_IS_PROGRESS (progress), 0);  progress_iface = GIMP_PROGRESS_GET_INTERFACE (progress);  if (progress_iface->get_window_id)    return progress_iface->get_window_id (progress);  return 0;}

voidgimp_drawable_foreground_extract_siox (GimpDrawable       *mask,                                       SioxState          *state,                                       SioxRefinementType  refinement,                                       gint                smoothness,                                       const gdouble       sensitivity[3],                                       gboolean            multiblob,                                       GimpProgress       *progress){  GeglBuffer *buffer;  gint        x1, y1;  gint        x2, y2;  g_return_if_fail (GIMP_IS_DRAWABLE (mask));  g_return_if_fail (babl_format_get_bytes_per_pixel (gimp_drawable_get_format (mask)) == 1);  g_return_if_fail (state != NULL);  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));  if (progress)    gimp_progress_start (progress, _("Foreground Extraction"), FALSE);  if (GIMP_IS_CHANNEL (mask))    {      gimp_channel_bounds (GIMP_CHANNEL (mask), &x1, &y1, &x2, &y2);    }  else    {      x1 = 0;      y1 = 0;      x2 = gimp_item_get_width  (GIMP_ITEM (mask));      y2 = gimp_item_get_height (GIMP_ITEM (mask));    }  buffer = gimp_drawable_get_buffer (mask);  siox_foreground_extract (state, refinement,                           gimp_gegl_buffer_get_tiles (buffer),                           x1, y1, x2, y2,                           smoothness, sensitivity, multiblob,                           (SioxProgressFunc) gimp_progress_set_value,                           progress);  if (progress)    gimp_progress_end (progress);  gimp_drawable_update (mask, x1, y1, x2, y2);}

voidgimp_progress_set_value (GimpProgress *progress,                         gdouble       percentage){  GimpProgressInterface *progress_iface;  g_return_if_fail (GIMP_IS_PROGRESS (progress));  percentage = CLAMP (percentage, 0.0, 1.0);  progress_iface = GIMP_PROGRESS_GET_INTERFACE (progress);  if (progress_iface->set_value)    progress_iface->set_value (progress, percentage);}

voidgimp_progress_set_text (GimpProgress *progress,                        const gchar  *message){  GimpProgressInterface *progress_iface;  g_return_if_fail (GIMP_IS_PROGRESS (progress));  if (! message || ! strlen (message))    message = _("Please wait");  progress_iface = GIMP_PROGRESS_GET_INTERFACE (progress);  if (progress_iface->set_text)    progress_iface->set_text (progress, message);}

voidgimp_image_resize_to_layers (GimpImage    *image,                             GimpContext  *context,                             GimpProgress *progress){  GList    *list;  GimpItem *item;  gint      x, y;  gint      width, height;  g_return_if_fail (GIMP_IS_IMAGE (image));  g_return_if_fail (GIMP_IS_CONTEXT (context));  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));  list = gimp_image_get_layer_iter (image);  if (! list)    return;  /* figure out starting values */  item = list->data;  x      = gimp_item_get_offset_x (item);  y      = gimp_item_get_offset_y (item);  width  = gimp_item_get_width  (item);  height = gimp_item_get_height (item);  /*  Respect all layers  */  for (list = g_list_next (list); list; list = g_list_next (list))    {      item = list->data;      gimp_rectangle_union (x, y,                            width, height,                            gimp_item_get_offset_x (item),                            gimp_item_get_offset_y (item),                            gimp_item_get_width  (item),                            gimp_item_get_height (item),                            &x, &y,                            &width, &height);    }  gimp_image_resize (image, context,                     width, height, -x, -y,                     progress);}

gintgimp_plug_in_progress_detach (GimpProgress *progress){  gint attach_count;  g_return_val_if_fail (GIMP_IS_PROGRESS (progress), 0);  attach_count =    GPOINTER_TO_INT (g_object_get_data (G_OBJECT (progress),                                        "plug-in-progress-attach-count"));  attach_count--;  g_object_set_data (G_OBJECT (progress), "plug-in-progress-attach-count",                     GINT_TO_POINTER (attach_count));  return attach_count;}

voidgimp_progress_set_text (GimpProgress *progress,                        const gchar  *format,                        ...){  va_list  args;  gchar   *message;  g_return_if_fail (GIMP_IS_PROGRESS (progress));  g_return_if_fail (format != NULL);  va_start (args, format);  message = g_strdup_vprintf (format, args);  va_end (args);  gimp_progress_set_text_literal (progress, message);  g_free (message);}

GimpProgress *gimp_progress_start (GimpProgress *progress,                     const gchar  *message,                     gboolean      cancelable){  GimpProgressInterface *progress_iface;  g_return_val_if_fail (GIMP_IS_PROGRESS (progress), NULL);  if (! message)    message = _("Please wait");  progress_iface = GIMP_PROGRESS_GET_INTERFACE (progress);  if (progress_iface->start)    return progress_iface->start (progress, message, cancelable);  return NULL;}

/** * gimp_item_scale_by_origin: * @item:         The item to be transformed by width & height scale factors * @new_width:    The width that item will acquire * @new_height:   The height that the item will acquire * @interpolation: * @progress: * @local_origin: sets fixed point of the scaling transform. See below. * * Sets item dimensions to new_width and * new_height. Derives vertical and horizontal scaling * transforms from new width and height. If local_origin is * #TRUE, the fixed point of the scaling transform coincides * with the item's center point.  Otherwise, the fixed * point is taken to be [-item->offset_x, -item->offset_y]. * * Since this function derives scale factors from new and * current item dimensions, these factors will vary from * item to item because of aliasing artifacts; factor * variations among items can be quite large where item * dimensions approach pixel dimensions. Use * gimp_item_scale_by_factors() where constant scales are to * be uniformly applied to a number of items. * * Side effects: undo set created for item. *               Old item imagery scaled *               & painted to new item tiles **/voidgimp_item_scale_by_origin (GimpItem              *item,                           gint                   new_width,                           gint                   new_height,                           GimpInterpolationType  interpolation,                           GimpProgress          *progress,                           gboolean               local_origin){  gint new_offset_x, new_offset_y;  g_return_if_fail (GIMP_IS_ITEM (item));  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));  if (new_width == 0 || new_height == 0)    {      g_warning ("%s: requested width or height equals zero", G_STRFUNC);      return;    }  if (local_origin)    {      new_offset_x = (item->offset_x +                      ((gimp_item_width  (item) - new_width)  / 2.0));      new_offset_y = (item->offset_y +                      ((gimp_item_height (item) - new_height) / 2.0));    }  else    {      new_offset_x = (gint) (((gdouble) new_width *                              (gdouble) item->offset_x /                              (gdouble) gimp_item_width (item)));      new_offset_y = (gint) (((gdouble) new_height *                              (gdouble) item->offset_y /                              (gdouble) gimp_item_height (item)));    }  gimp_item_scale (item,                   new_width, new_height,                   new_offset_x, new_offset_y,                   interpolation, progress);}

voidgimp_gegl_apply_invert_linear (GeglBuffer    *src_buffer,                               GimpProgress  *progress,                               const gchar   *undo_desc,                               GeglBuffer    *dest_buffer){  GeglNode *node;  g_return_if_fail (GEGL_IS_BUFFER (src_buffer));  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));  g_return_if_fail (GEGL_IS_BUFFER (dest_buffer));  node = gegl_node_new_child (NULL,                              "operation", "gegl:invert-linear",                              NULL);  gimp_gegl_apply_operation (src_buffer, progress, undo_desc,                             node, dest_buffer, NULL);  g_object_unref (node);}

voidgimp_gegl_apply_flatten (GeglBuffer    *src_buffer,                         GimpProgress  *progress,                         const gchar   *undo_desc,                         GeglBuffer    *dest_buffer,                         const GimpRGB *background){  GeglNode *node;  g_return_if_fail (GEGL_IS_BUFFER (src_buffer));  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));  g_return_if_fail (GEGL_IS_BUFFER (dest_buffer));  g_return_if_fail (background != NULL);  node = gimp_gegl_create_flatten_node (background);  gimp_gegl_apply_operation (src_buffer, progress, undo_desc,                             node, dest_buffer, NULL);  g_object_unref (node);}

gbooleangimp_item_stroke (GimpItem        *item,                  GimpDrawable    *drawable,                  GimpContext     *context,                  GimpStrokeDesc  *stroke_desc,                  gboolean         use_default_values,                  GimpProgress    *progress,                  GError         **error){  GimpItemClass *item_class;  gboolean       retval = FALSE;  g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE);  g_return_val_if_fail (gimp_item_is_attached (item), FALSE);  g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE);  g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), FALSE);  g_return_val_if_fail (GIMP_IS_CONTEXT (context), FALSE);  g_return_val_if_fail (GIMP_IS_STROKE_DESC (stroke_desc), FALSE);  g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), FALSE);  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);  item_class = GIMP_ITEM_GET_CLASS (item);  if (item_class->stroke)    {      GimpImage *image = gimp_item_get_image (item);      gimp_stroke_desc_prepare (stroke_desc, context, use_default_values);      gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_PAINT,                                   item_class->stroke_desc);      retval = item_class->stroke (item, drawable, stroke_desc, progress, error);      gimp_image_undo_group_end (image);      gimp_stroke_desc_finish (stroke_desc);    }  return retval;}

GimpPlugInProcFrame *gimp_plug_in_proc_frame_push (GimpPlugIn             *plug_in,                              GimpContext            *context,                              GimpProgress           *progress,                              GimpTemporaryProcedure *procedure){  GimpPlugInProcFrame *proc_frame;  g_return_val_if_fail (GIMP_IS_PLUG_IN (plug_in), NULL);  g_return_val_if_fail (GIMP_IS_PDB_CONTEXT (context), NULL);  g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), NULL);  g_return_val_if_fail (GIMP_IS_TEMPORARY_PROCEDURE (procedure), NULL);  proc_frame = gimp_plug_in_proc_frame_new (context, progress,                                            GIMP_PLUG_IN_PROCEDURE (procedure));  plug_in->temp_proc_frames = g_list_prepend (plug_in->temp_proc_frames,                                              proc_frame);  return proc_frame;}

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

voidgimp_gegl_apply_feather (GeglBuffer   *src_buffer,                         GimpProgress *progress,                         const gchar  *undo_desc,                         GeglBuffer   *dest_buffer,                         gdouble       radius_x,                         gdouble       radius_y){  g_return_if_fail (GEGL_IS_BUFFER (src_buffer));  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));  g_return_if_fail (GEGL_IS_BUFFER (dest_buffer));  /* 3.5 is completely magic and picked to visually match the old   * gaussian_blur_region() on a crappy laptop display   */  gimp_gegl_apply_gaussian_blur (src_buffer,                                 progress, undo_desc,                                 dest_buffer,                                 radius_x / 3.5,                                 radius_y / 3.5);}

voidgimp_gegl_apply_threshold (GeglBuffer    *src_buffer,                           GimpProgress  *progress,                           const gchar   *undo_desc,                           GeglBuffer    *dest_buffer,                           gdouble        value){  GeglNode *node;  g_return_if_fail (GEGL_IS_BUFFER (src_buffer));  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));  g_return_if_fail (GEGL_IS_BUFFER (dest_buffer));  node = gegl_node_new_child (NULL,                              "operation", "gegl:threshold",                              "value",     value,                              NULL);  gimp_gegl_apply_operation (src_buffer, progress, undo_desc,                             node, dest_buffer, NULL);  g_object_unref (node);}

static GtkWidget *progress_error_dialog (GimpProgress *progress){  GtkWidget *dialog;  g_return_val_if_fail (GIMP_IS_PROGRESS (progress), NULL);  dialog = g_object_get_data (G_OBJECT (progress), "gimp-error-dialog");  if (! dialog)    {      dialog = gimp_error_dialog_new (_("GIMP Message"));      g_object_set_data (G_OBJECT (progress), "gimp-error-dialog", dialog);      g_signal_connect_object (dialog, "destroy",                               G_CALLBACK (progress_error_dialog_unset),                               progress, G_CONNECT_SWAPPED);      if (GTK_IS_WIDGET (progress))        {          GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (progress));          if (GTK_IS_WINDOW (toplevel))            gtk_window_set_transient_for (GTK_WINDOW (dialog),                                          GTK_WINDOW (toplevel));        }      else        {          guint32 window = gimp_progress_get_window (progress);          if (window)            gimp_window_set_transient_for (GTK_WINDOW (dialog), window);        }    }  return dialog;}

GFile *file_remote_download_image (Gimp          *gimp,                            GFile         *file,                            gboolean      *mounted,                            GimpProgress  *progress,                            GError       **error){  GFile *local_file;  g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);  g_return_val_if_fail (G_IS_FILE (file), NULL);  g_return_val_if_fail (mounted != NULL, NULL);  g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), NULL);  g_return_val_if_fail (error == NULL || *error == NULL, NULL);  local_file = file_remote_mount_file (gimp, file, progress);  if (local_file)    {      *mounted = TRUE;    }  else    {      *mounted = FALSE;      local_file = file_remote_get_temp_file (gimp, file);      if (! file_remote_copy_file (gimp, file, local_file, DOWNLOAD,                                   progress, error))        {          g_object_unref (local_file);          return NULL;        }    }  return local_file;}

voidgimp_show_message (Gimp                *gimp,                   GObject             *handler,                   GimpMessageSeverity  severity,                   const gchar         *domain,                   const gchar         *message){  const gchar *desc = "Message";  g_return_if_fail (GIMP_IS_GIMP (gimp));  g_return_if_fail (handler == NULL || G_IS_OBJECT (handler));  g_return_if_fail (message != NULL);  if (! domain)    domain = GIMP_ACRONYM;  if (! gimp->console_messages)    {      if (gimp->gui.show_message)        {          gimp->gui.show_message (gimp, handler,                                  severity, domain, message);          return;        }      else if (GIMP_IS_PROGRESS (handler) &&               gimp_progress_message (GIMP_PROGRESS (handler), gimp,                                      severity, domain, message))        {          /* message has been handled by GimpProgress */          return;        }    }  gimp_enum_get_value (GIMP_TYPE_MESSAGE_SEVERITY, severity,                       NULL, NULL, &desc, NULL);  g_printerr ("%s-%s: %s/n/n", domain, desc, message);}

voidgimp_drawable_apply_operation (GimpDrawable *drawable,                               GimpProgress *progress,                               const gchar  *undo_desc,                               GeglNode     *operation,                               gboolean      linear){  GeglRectangle rect;  g_return_if_fail (GIMP_IS_DRAWABLE (drawable));  g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)));  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));  g_return_if_fail (undo_desc != NULL);  g_return_if_fail (GEGL_IS_NODE (operation));  if (! gimp_item_mask_intersect (GIMP_ITEM (drawable),                                  &rect.x,     &rect.y,                                  &rect.width, &rect.height))    return;  gimp_drawable_apply_operation_private (drawable,                                         progress,                                         undo_desc,                                         operation,                                         linear,                                         gimp_drawable_get_shadow_tiles (drawable),                                         &rect);  gimp_drawable_merge_shadow_tiles (drawable, TRUE, undo_desc);  gimp_drawable_free_shadow_tiles (drawable);  gimp_drawable_update (drawable, rect.x, rect.y, rect.width, rect.height);  if (progress)    gimp_progress_end (progress);}

voidgimp_gegl_apply_gaussian_blur (GeglBuffer   *src_buffer,                               GimpProgress *progress,                               const gchar  *undo_desc,                               GeglBuffer   *dest_buffer,                               gdouble       std_dev_x,                               gdouble       std_dev_y){  GeglNode *node;  g_return_if_fail (GEGL_IS_BUFFER (src_buffer));  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));  g_return_if_fail (GEGL_IS_BUFFER (dest_buffer));  node = gegl_node_new_child (NULL,                              "operation", "gegl:gaussian-blur",                              "std-dev-x", std_dev_x,                              "std-dev-y", std_dev_y,                              NULL);  gimp_gegl_apply_operation (src_buffer, progress, undo_desc,                             node, dest_buffer, NULL);  g_object_unref (node);}