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

voidaction_message (GimpDisplay *display,                GObject     *object,                const gchar *format,                ...){  GimpDisplayShell *shell     = gimp_display_get_shell (display);  GimpStatusbar    *statusbar = gimp_display_shell_get_statusbar (shell);  const gchar      *icon_name = NULL;  va_list           args;  if (GIMP_IS_TOOL_OPTIONS (object))    {      GimpToolInfo *tool_info = GIMP_TOOL_OPTIONS (object)->tool_info;      icon_name = gimp_viewable_get_icon_name (GIMP_VIEWABLE (tool_info));    }  else if (GIMP_IS_VIEWABLE (object))    {      icon_name = gimp_viewable_get_icon_name (GIMP_VIEWABLE (object));    }  va_start (args, format);  gimp_statusbar_push_temp_valist (statusbar, GIMP_MESSAGE_INFO,                                   icon_name, format, args);  va_end (args);}

voidcolormap_edit_color_cmd_callback (GtkAction *action,                                  gpointer   data){  GimpColormapEditor *editor;  GimpImage          *image;  const guchar       *colormap;  GimpRGB             color;  gchar              *desc;  return_if_no_image (image, data);  editor = GIMP_COLORMAP_EDITOR (data);  colormap = gimp_image_get_colormap (image);  gimp_rgba_set_uchar (&color,                       colormap[editor->col_index * 3],                       colormap[editor->col_index * 3 + 1],                       colormap[editor->col_index * 3 + 2],                       OPAQUE_OPACITY);  desc = g_strdup_printf (_("Edit colormap entry #%d"), editor->col_index);  if (! editor->color_dialog)    {      editor->color_dialog =        gimp_color_dialog_new (GIMP_VIEWABLE (image),                               action_data_get_context (data),                               _("Edit Colormap Entry"),                               GIMP_STOCK_COLORMAP,                               desc,                               GTK_WIDGET (editor),                               gimp_dialog_factory_from_name ("toplevel"),                               "gimp-colormap-editor-color-dialog",                               (const GimpRGB *) &color,                               FALSE, FALSE);      g_signal_connect (editor->color_dialog, "destroy",                        G_CALLBACK (gtk_widget_destroyed),                        &editor->color_dialog);      g_signal_connect (editor->color_dialog, "update",                        G_CALLBACK (colormap_edit_color_update),                        editor);    }  else    {      gimp_viewable_dialog_set_viewable (GIMP_VIEWABLE_DIALOG (editor->color_dialog),                                         GIMP_VIEWABLE (image),                                         action_data_get_context (data));      g_object_set (editor->color_dialog, "description", desc, NULL);      gimp_color_dialog_set_color (GIMP_COLOR_DIALOG (editor->color_dialog),                                   &color);    }  g_free (desc);  gtk_window_present (GTK_WINDOW (editor->color_dialog));}

voidgimp_paint_core_finish (GimpPaintCore *core,                        GimpDrawable  *drawable,                        gboolean       push_undo){  GimpImage *image;  g_return_if_fail (GIMP_IS_PAINT_CORE (core));  g_return_if_fail (GIMP_IS_DRAWABLE (drawable));  g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)));  if (core->stroke_buffer)    {      g_array_free (core->stroke_buffer, TRUE);      core->stroke_buffer = NULL;    }  image = gimp_item_get_image (GIMP_ITEM (drawable));  /*  Determine if any part of the image has been altered--   *  if nothing has, then just return...   */  if ((core->x2 == core->x1) || (core->y2 == core->y1))    {      gimp_viewable_preview_thaw (GIMP_VIEWABLE (drawable));      return;    }  if (push_undo)    {      gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_PAINT,                                   core->undo_desc);      GIMP_PAINT_CORE_GET_CLASS (core)->push_undo (core, image, NULL);      gimp_drawable_push_undo (drawable, NULL,                               core->x1, core->y1,                               core->x2 - core->x1, core->y2 - core->y1,                               core->undo_tiles,                               TRUE);      gimp_image_undo_group_end (image);    }  tile_manager_unref (core->undo_tiles);  core->undo_tiles = NULL;  if (core->saved_proj_tiles)    {      tile_manager_unref (core->saved_proj_tiles);      core->saved_proj_tiles = NULL;    }  gimp_viewable_preview_thaw (GIMP_VIEWABLE (drawable));}

static voidgimp_undo_create_preview_private (GimpUndo    *undo,                                  GimpContext *context){  GimpImage    *image = undo->image;  GimpViewable *preview_viewable;  GimpViewSize  preview_size;  gint          width;  gint          height;  switch (undo->undo_type)    {    case GIMP_UNDO_GROUP_IMAGE_QUICK_MASK:    case GIMP_UNDO_GROUP_MASK:    case GIMP_UNDO_MASK:      preview_viewable = GIMP_VIEWABLE (gimp_image_get_mask (image));      break;    default:      preview_viewable = GIMP_VIEWABLE (image);      break;    }  preview_size = image->gimp->config->undo_preview_size;  if (gimp_image_get_width  (image) <= preview_size &&      gimp_image_get_height (image) <= preview_size)    {      width  = gimp_image_get_width  (image);      height = gimp_image_get_height (image);    }  else    {      if (gimp_image_get_width (image) > gimp_image_get_height (image))        {          width  = preview_size;          height = MAX (1, (gimp_image_get_height (image) * preview_size /                            gimp_image_get_width (image)));        }      else        {          height = preview_size;          width  = MAX (1, (gimp_image_get_width (image) * preview_size /                            gimp_image_get_height (image)));        }    }  undo->preview = gimp_viewable_get_new_preview (preview_viewable, context,                                                 width, height);  gimp_viewable_invalidate_preview (GIMP_VIEWABLE (undo));}

voidgimp_tool_replace_status (GimpTool    *tool,                          GimpDisplay *display,                          const gchar *format,                          ...){  GimpDisplayShell *shell;  const gchar      *stock_id;  va_list           args;  g_return_if_fail (GIMP_IS_TOOL (tool));  g_return_if_fail (GIMP_IS_DISPLAY (display));  g_return_if_fail (format != NULL);  shell = GIMP_DISPLAY_SHELL (display->shell);  stock_id = gimp_viewable_get_stock_id (GIMP_VIEWABLE (tool->tool_info));  va_start (args, format);  gimp_statusbar_replace_valist (GIMP_STATUSBAR (shell->statusbar),                                 G_OBJECT_TYPE_NAME (tool), stock_id,                                 format, args);  va_end (args);  tool->status_displays = g_list_remove (tool->status_displays, display);  tool->status_displays = g_list_prepend (tool->status_displays, display);}

voidgimp_tool_push_status_length (GimpTool            *tool,                              GimpDisplay         *display,                              const gchar         *title,                              GimpOrientationType  axis,                              gdouble              value,                              const gchar         *help){  GimpDisplayShell *shell;  const gchar      *stock_id;  g_return_if_fail (GIMP_IS_TOOL (tool));  g_return_if_fail (GIMP_IS_DISPLAY (display));  shell = GIMP_DISPLAY_SHELL (display->shell);  stock_id = gimp_viewable_get_stock_id (GIMP_VIEWABLE (tool->tool_info));  gimp_statusbar_push_length (GIMP_STATUSBAR (shell->statusbar),                              G_OBJECT_TYPE_NAME (tool), stock_id,                              title, axis, value, help);  tool->status_displays = g_list_remove (tool->status_displays, display);  tool->status_displays = g_list_prepend (tool->status_displays, display);}

voidgimp_tool_push_status_coords (GimpTool            *tool,                              GimpDisplay         *display,                              GimpCursorPrecision  precision,                              const gchar         *title,                              gdouble              x,                              const gchar         *separator,                              gdouble              y,                              const gchar         *help){  GimpDisplayShell *shell;  const gchar      *stock_id;  g_return_if_fail (GIMP_IS_TOOL (tool));  g_return_if_fail (GIMP_IS_DISPLAY (display));  shell = GIMP_DISPLAY_SHELL (display->shell);  stock_id = gimp_viewable_get_stock_id (GIMP_VIEWABLE (tool->tool_info));  gimp_statusbar_push_coords (GIMP_STATUSBAR (shell->statusbar),                              G_OBJECT_TYPE_NAME (tool), stock_id,                              precision, title, x, separator, y,                              help);  tool->status_displays = g_list_remove (tool->status_displays, display);  tool->status_displays = g_list_prepend (tool->status_displays, display);}

static voidgimp_container_entry_changed (GtkEntry          *entry,                              GimpContainerView *view){  GimpContainer *container = gimp_container_view_get_container (view);  GimpObject    *object;  const gchar   *text;  if (! container)    return;  text = gtk_entry_get_text (entry);  object = gimp_container_get_child_by_name (container, text);  if (object)    {      gtk_widget_modify_text (GTK_WIDGET (entry), GTK_STATE_NORMAL, NULL);      gimp_container_view_item_selected (view, GIMP_VIEWABLE (object));    }  else    {      /* While editing the entry, contents shows in red for non-existent item. */      GdkColor     gdk_red;      gdk_red.red = 65535;      gdk_red.green = 0;      gdk_red.blue = 0;      gtk_widget_modify_text (GTK_WIDGET (entry), GTK_STATE_NORMAL, &gdk_red);    }}

/** * gimp_image_scale_check: * @image:      A #GimpImage. * @new_width:   The new width. * @new_height:  The new height. * @max_memsize: The maximum new memory size. * @new_memsize: The new memory size. * * Inventory the layer list in image and check that it may be * scaled to @new_height and @new_width without problems. * * Return value: #GIMP_IMAGE_SCALE_OK if scaling the image will shrink none *               of its layers completely away, and the new image size *               is smaller than @max_memsize. *               #GIMP_IMAGE_SCALE_TOO_SMALL if scaling would remove some *               existing layers. *               #GIMP_IMAGE_SCALE_TOO_BIG if the new image size would *               exceed the maximum specified in the preferences. **/GimpImageScaleCheckTypegimp_image_scale_check (GimpImage *image,                        gint       new_width,                        gint       new_height,                        gint64     max_memsize,                        gint64    *new_memsize){  GList  *all_layers;  GList  *list;  gint64  current_size;  gint64  undo_size;  gint64  redo_size;  gint64  new_size;  g_return_val_if_fail (GIMP_IS_IMAGE (image), GIMP_IMAGE_SCALE_TOO_SMALL);  g_return_val_if_fail (new_memsize != NULL, GIMP_IMAGE_SCALE_TOO_SMALL);  current_size = gimp_object_get_memsize (GIMP_OBJECT (image), NULL);  new_size = gimp_image_estimate_memsize (image,                                          gimp_image_get_component_type (image),                                          new_width, new_height);  undo_size = gimp_object_get_memsize (GIMP_OBJECT (gimp_image_get_undo_stack (image)), NULL);  redo_size = gimp_object_get_memsize (GIMP_OBJECT (gimp_image_get_redo_stack (image)), NULL);  current_size -= undo_size + redo_size;  new_size     -= undo_size + redo_size;  GIMP_LOG (IMAGE_SCALE,            "old_size = %"G_GINT64_FORMAT"  new_size = %"G_GINT64_FORMAT,            current_size, new_size);  *new_memsize = new_size;  if (new_size > current_size && new_size > max_memsize)    return GIMP_IMAGE_SCALE_TOO_BIG;  all_layers = gimp_image_get_layer_list (image);  for (list = all_layers; list; list = g_list_next (list))    {      GimpItem *item = list->data;      /*  group layers are updated automatically  */      if (gimp_viewable_get_children (GIMP_VIEWABLE (item)))        continue;      if (! gimp_item_check_scaling (item, new_width, new_height))        {          g_list_free (all_layers);          return GIMP_IMAGE_SCALE_TOO_SMALL;        }    }  g_list_free (all_layers);  return GIMP_IMAGE_SCALE_OK;}

static voidgimp_histogram_editor_frozen_update (GimpHistogramEditor *editor,                                     const GParamSpec    *pspec){  GimpHistogramView *view = GIMP_HISTOGRAM_BOX (editor->box)->view;  if (gimp_viewable_preview_is_frozen (GIMP_VIEWABLE (editor->drawable)))    {      /* Only do the background histogram if the histogram is visible.       * This is a workaround for the fact that recalculating the       * histogram is expensive and that it is only validated when it       * is shown. So don't slow down painting by doing something that       * is not even seen by the user.       */      if (! editor->bg_histogram && GTK_WIDGET_DRAWABLE (editor))        {          if (gimp_histogram_editor_validate (editor))            editor->bg_histogram = gimp_histogram_duplicate (editor->histogram);          gimp_histogram_view_set_background (view, editor->bg_histogram);        }    }  else if (editor->bg_histogram)    {      gimp_histogram_unref (editor->bg_histogram);      editor->bg_histogram = NULL;      gimp_histogram_view_set_background (view, NULL);    }}

voidfloating_sel_remove (GimpLayer *layer){  GimpImage *image;  g_return_if_fail (GIMP_IS_LAYER (layer));  g_return_if_fail (gimp_layer_is_floating_sel (layer));  image = gimp_item_get_image (GIMP_ITEM (layer->fs.drawable));  gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_FS_REMOVE,                               _("Remove Floating Selection"));  /*  store the affected area from the drawable in the backing store  */  floating_sel_relax (layer, TRUE);  /*  Invalidate the preview of the obscured drawable.  We do this here   *  because it will not be done until the floating selection is removed,   *  at which point the obscured drawable's preview will not be declared   *  invalid.   */  gimp_viewable_invalidate_preview (GIMP_VIEWABLE (layer));  /*  remove the layer from the image  */  gimp_image_remove_layer (image, layer);  gimp_image_undo_group_end (image);}

GimpVectors *gimp_vectors_get_parent (GimpVectors *vectors){  g_return_val_if_fail (GIMP_IS_VECTORS (vectors), NULL);  return GIMP_VECTORS (gimp_viewable_get_parent (GIMP_VIEWABLE (vectors)));}

static voidimage_scale_confirm_response (GtkWidget        *widget,                              gint              response_id,                              ImageScaleDialog *dialog){  gtk_widget_destroy (widget);  if (response_id == GTK_RESPONSE_OK)    {      gtk_widget_hide (dialog->dialog);      dialog->callback (dialog->dialog,                        GIMP_VIEWABLE (dialog->image),                        dialog->width,                        dialog->height,                        dialog->unit,                        dialog->interpolation,                        dialog->xresolution,                        dialog->yresolution,                        dialog->resolution_unit,                        dialog->user_data);      gtk_widget_destroy (dialog->dialog);    }  else    {      gtk_widget_set_sensitive (dialog->dialog, TRUE);    }}

voidgimp_text_layer_set_text (GimpTextLayer *layer,                          GimpText      *text){  g_return_if_fail (GIMP_IS_TEXT_LAYER (layer));  g_return_if_fail (text == NULL || GIMP_IS_TEXT (text));  if (layer->text == text)    return;  if (layer->text)    {      g_signal_handlers_disconnect_by_func (layer->text,                                            G_CALLBACK (gimp_text_layer_text_changed),                                            layer);      g_object_unref (layer->text);      layer->text = NULL;    }  if (text)    {      layer->text = g_object_ref (text);      g_signal_connect_object (text, "changed",                               G_CALLBACK (gimp_text_layer_text_changed),                               layer, G_CONNECT_SWAPPED);    }  g_object_notify (G_OBJECT (layer), "text");  gimp_viewable_invalidate_preview (GIMP_VIEWABLE (layer));}

static voidgimp_selection_editor_set_image (GimpImageEditor *image_editor,                                 GimpImage       *image){  GimpSelectionEditor *editor = GIMP_SELECTION_EDITOR (image_editor);  if (image_editor->image)    {      g_signal_handlers_disconnect_by_func (image_editor->image,                                            gimp_selection_editor_mask_changed,                                            editor);    }  GIMP_IMAGE_EDITOR_CLASS (parent_class)->set_image (image_editor, image);  if (image)    {      g_signal_connect (image, "mask-changed",                        G_CALLBACK (gimp_selection_editor_mask_changed),                        editor);      gimp_view_set_viewable (GIMP_VIEW (editor->view),                              GIMP_VIEWABLE (gimp_image_get_mask (image)));    }  else    {      gimp_view_set_viewable (GIMP_VIEW (editor->view), NULL);    }}

static voidgimp_display_shell_drop_buffer (GtkWidget    *widget,                                gint          drop_x,                                gint          drop_y,                                GimpViewable *viewable,                                gpointer      data){  GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (data);  GimpImage        *image = gimp_display_get_image (shell->display);  GimpDrawable     *drawable;  GimpBuffer       *buffer;  gint              x, y, width, height;  GIMP_LOG (DND, NULL);  if (shell->display->gimp->busy)    return;  if (! image)    {      image = gimp_image_new_from_buffer (shell->display->gimp, NULL,                                          GIMP_BUFFER (viewable));      gimp_create_display (image->gimp, image, GIMP_UNIT_PIXEL, 1.0);      g_object_unref (image);      return;    }  drawable = gimp_image_get_active_drawable (image);  if (drawable)    {      if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable)))        {          gimp_message_literal (shell->display->gimp, G_OBJECT (shell->display),                                GIMP_MESSAGE_ERROR,                                _("Cannot modify the pixels of layer groups."));          return;        }      if (gimp_item_is_content_locked (GIMP_ITEM (drawable)))        {          gimp_message_literal (shell->display->gimp, G_OBJECT (shell->display),                                GIMP_MESSAGE_ERROR,                                _("The active layer's pixels are locked."));          return;        }    }  buffer = GIMP_BUFFER (viewable);  gimp_display_shell_untransform_viewport (shell, &x, &y, &width, &height);  /* FIXME: popup a menu for selecting "Paste Into" */  gimp_edit_paste (image, drawable, buffer, FALSE,                   x, y, width, height);  gimp_display_shell_dnd_flush (shell, image);}

static gbooleangimp_bucket_fill_tool_initialize (GimpTool     *tool,                                  GimpDisplay  *display,                                  GError      **error){  GimpImage    *image    = gimp_display_get_image (display);  GimpDrawable *drawable = gimp_image_get_active_drawable (image);  if (! GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error))    {      return FALSE;    }  if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable)))    {      g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED,			   _("Cannot modify the pixels of layer groups."));      return FALSE;    }  if (gimp_item_is_content_locked (GIMP_ITEM (drawable)))    {      g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED,			   _("The active layer's pixels are locked."));      return FALSE;    }  return TRUE;}

static voidgimp_clipboard_send_buffer (GtkClipboard     *clipboard,                            GtkSelectionData *selection_data,                            guint             info,                            Gimp             *gimp){  GimpClipboard *gimp_clip = gimp_clipboard_get (gimp);  GdkPixbuf     *pixbuf;  gimp_set_busy (gimp);  pixbuf = gimp_viewable_get_pixbuf (GIMP_VIEWABLE (gimp_clip->buffer),                                     gimp_get_user_context (gimp),                                     gimp_buffer_get_width (gimp_clip->buffer),                                     gimp_buffer_get_height (gimp_clip->buffer));  if (pixbuf)    {      if (gimp->be_verbose)        g_printerr ("clipboard: sending pixbuf data as '%s'/n",                    gimp_clip->target_entries[info].target);      gtk_selection_data_set_pixbuf (selection_data, pixbuf);    }  else    {      g_warning ("%s: gimp_viewable_get_pixbuf() failed", G_STRFUNC);    }  gimp_unset_busy (gimp);}

static voidgimp_color_selector_palette_palette_changed (GimpContext              *context,                                             GimpPalette              *palette,                                             GimpColorSelectorPalette *select){  gimp_view_set_viewable (GIMP_VIEW (select->view), GIMP_VIEWABLE (palette));}

static voidgimp_image_map_tool_create_map (GimpImageMapTool *tool){  GimpImageMapOptions *options   = GIMP_IMAGE_MAP_TOOL_GET_OPTIONS (tool);  GimpToolInfo        *tool_info = GIMP_TOOL (tool)->tool_info;  if (tool->image_map)    {      gimp_image_map_abort (tool->image_map);      g_object_unref (tool->image_map);    }  g_assert (tool->operation);  tool->image_map = gimp_image_map_new (tool->drawable,                                        tool->undo_desc,                                        tool->operation,                                        gimp_viewable_get_icon_name (GIMP_VIEWABLE (tool_info)));  gimp_image_map_set_region (tool->image_map, options->region);  g_signal_connect (tool->image_map, "flush",                    G_CALLBACK (gimp_image_map_tool_flush),                    tool);}

static voidtool_options_actions_update_presets (GimpActionGroup *group,                                     const gchar     *action_prefix,                                     GCallback        callback,                                     const gchar     *help_id,                                     GimpContainer   *presets){  GList *list;  gint   n_children = 0;  gint   i;  for (i = 0; ; i++)    {      gchar     *action_name;      GtkAction *action;      action_name = g_strdup_printf ("%s-%03d", action_prefix, i);      action = gtk_action_group_get_action (GTK_ACTION_GROUP (group),                                            action_name);      g_free (action_name);      if (! action)        break;      gtk_action_group_remove_action (GTK_ACTION_GROUP (group), action);    }  if (presets)    n_children = gimp_container_get_n_children (presets);  if (n_children > 0)    {      GimpEnumActionEntry entry;      entry.name           = NULL;      entry.label          = NULL;      entry.accelerator    = "";      entry.tooltip        = NULL;      entry.value          = 0;      entry.value_variable = FALSE;      entry.help_id        = help_id;      for (list = GIMP_LIST (presets)->list, i = 0;           list;           list = g_list_next (list), i++)        {          GimpObject *options = list->data;          entry.name     = g_strdup_printf ("%s-%03d", action_prefix, i);          entry.label    = gimp_object_get_name (options);          entry.stock_id = gimp_viewable_get_stock_id (GIMP_VIEWABLE (options));          entry.value    = i;          gimp_action_group_add_enum_actions (group, NULL, &entry, 1, callback);          g_free ((gchar *) entry.name);        }    }}

voidpalette_editor_edit_color_cmd_callback (GtkAction *action,                                        gpointer   data){  GimpPaletteEditor *editor      = GIMP_PALETTE_EDITOR (data);  GimpDataEditor    *data_editor = GIMP_DATA_EDITOR (data);  GimpPalette       *palette;  if (! (data_editor->data_editable && editor->color))    return;  palette = GIMP_PALETTE (data_editor->data);  if (! editor->color_dialog)    {      editor->color_dialog =        gimp_color_dialog_new (GIMP_VIEWABLE (palette),                               data_editor->context,                               _("Edit Palette Color"),                               GIMP_STOCK_PALETTE,                               _("Edit Color Palette Entry"),                               GTK_WIDGET (editor),                               gimp_dialog_factory_get_singleton (),                               "gimp-palette-editor-color-dialog",                               &editor->color->color,                               FALSE, FALSE);      g_signal_connect (editor->color_dialog, "destroy",                        G_CALLBACK (gtk_widget_destroyed),                        &editor->color_dialog);      g_signal_connect (editor->color_dialog, "update",                        G_CALLBACK (palette_editor_edit_color_update),                        editor);    }  else    {      gimp_viewable_dialog_set_viewable (GIMP_VIEWABLE_DIALOG (editor->color_dialog),                                         GIMP_VIEWABLE (palette),                                         data_editor->context);      gimp_color_dialog_set_color (GIMP_COLOR_DIALOG (editor->color_dialog),                                   &editor->color->color);    }  gtk_window_present (GTK_WINDOW (editor->color_dialog));}

static voidedit_actions_pattern_changed (GimpContext     *context,                              GimpPattern     *pattern,                              GimpActionGroup *group){  gimp_action_group_set_action_viewable (group, "edit-fill-pattern",                                         GIMP_VIEWABLE (pattern));}

static voidgimp_paint_tool_cursor_update (GimpTool         *tool,                               const GimpCoords *coords,                               GdkModifierType   state,                               GimpDisplay      *display){  GimpPaintTool      *paint_tool = GIMP_PAINT_TOOL (tool);  GimpCursorModifier  modifier;  GimpCursorModifier  toggle_modifier;  GimpCursorModifier  old_modifier;  GimpCursorModifier  old_toggle_modifier;  modifier        = tool->control->cursor_modifier;  toggle_modifier = tool->control->toggle_cursor_modifier;  old_modifier        = modifier;  old_toggle_modifier = toggle_modifier;  if (! gimp_color_tool_is_enabled (GIMP_COLOR_TOOL (tool)))    {      GimpImage    *image    = gimp_display_get_image (display);      GimpDrawable *drawable = gimp_image_get_active_drawable (image);      if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable)) ||          gimp_item_is_content_locked (GIMP_ITEM (drawable))    ||          ! gimp_item_is_visible (GIMP_ITEM (drawable)))        {          modifier        = GIMP_CURSOR_MODIFIER_BAD;          toggle_modifier = GIMP_CURSOR_MODIFIER_BAD;        }      if (! paint_tool->show_cursor &&          modifier != GIMP_CURSOR_MODIFIER_BAD)        {          gimp_tool_set_cursor (tool, display,                                GIMP_CURSOR_NONE,                                GIMP_TOOL_CURSOR_NONE,                                GIMP_CURSOR_MODIFIER_NONE);          return;        }      gimp_tool_control_set_cursor_modifier        (tool->control,                                                    modifier);      gimp_tool_control_set_toggle_cursor_modifier (tool->control,                                                    toggle_modifier);    }  GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state,                                                 display);  /*  reset old stuff here so we are not interferring with the modifiers   *  set by our subclasses   */  gimp_tool_control_set_cursor_modifier        (tool->control,                                                old_modifier);  gimp_tool_control_set_toggle_cursor_modifier (tool->control,                                                old_toggle_modifier);}

static voidgimp_navigation_editor_set_shell (GimpNavigationEditor *editor,                                  GimpDisplayShell     *shell){  g_return_if_fail (GIMP_IS_NAVIGATION_EDITOR (editor));  g_return_if_fail (! shell || GIMP_IS_DISPLAY_SHELL (shell));  if (shell == editor->shell)    return;  if (editor->shell)    {      g_signal_handlers_disconnect_by_func (editor->shell,                                            gimp_navigation_editor_shell_scaled,                                            editor);      g_signal_handlers_disconnect_by_func (editor->shell,                                            gimp_navigation_editor_shell_scrolled,                                            editor);      g_signal_handlers_disconnect_by_func (editor->shell,                                            gimp_navigation_editor_shell_reconnect,                                            editor);    }  else if (shell)    {      gtk_widget_set_sensitive (GTK_WIDGET (editor), TRUE);    }  editor->shell = shell;  if (editor->shell)    {      GimpImage *image = gimp_display_get_image (shell->display);      gimp_view_set_viewable (GIMP_VIEW (editor->view),                              GIMP_VIEWABLE (image));      g_signal_connect (editor->shell, "scaled",                        G_CALLBACK (gimp_navigation_editor_shell_scaled),                        editor);      g_signal_connect (editor->shell, "scrolled",                        G_CALLBACK (gimp_navigation_editor_shell_scrolled),                        editor);      g_signal_connect (editor->shell, "reconnect",                        G_CALLBACK (gimp_navigation_editor_shell_reconnect),                        editor);      gimp_navigation_editor_shell_scaled (editor->shell, editor);    }  else    {      gimp_view_set_viewable (GIMP_VIEW (editor->view), NULL);      gtk_widget_set_sensitive (GTK_WIDGET (editor), FALSE);    }  if (gimp_editor_get_ui_manager (GIMP_EDITOR (editor)))    gimp_ui_manager_update (gimp_editor_get_ui_manager (GIMP_EDITOR (editor)),                            gimp_editor_get_popup_data (GIMP_EDITOR (editor)));}

static voidplug_in_actions_add_proc (GimpActionGroup     *group,                          GimpPlugInProcedure *proc){  GimpProcedureActionEntry  entry;  const gchar              *locale_domain;  GList                    *list;  locale_domain = gimp_plug_in_procedure_get_locale_domain (proc);  entry.name        = gimp_object_get_name (proc);  entry.icon_name   = gimp_viewable_get_icon_name (GIMP_VIEWABLE (proc));  entry.label       = gimp_procedure_get_menu_label (GIMP_PROCEDURE (proc));  entry.accelerator = NULL;  entry.tooltip     = gimp_procedure_get_blurb (GIMP_PROCEDURE (proc));  entry.procedure   = GIMP_PROCEDURE (proc);  entry.help_id     = gimp_procedure_get_help_id (GIMP_PROCEDURE (proc));  gimp_action_group_add_procedure_actions (group, &entry, 1,                                           G_CALLBACK (plug_in_run_cmd_callback));  for (list = proc->menu_paths; list; list = g_list_next (list))    {      const gchar *original   = list->data;      const gchar *translated = dgettext (locale_domain, original);      if (plug_in_actions_check_translation (original, translated))        plug_in_actions_build_path (group, original, translated);      else        plug_in_actions_build_path (group, original, original);    }  if (proc->image_types_val)    {      GimpContext  *context  = gimp_get_user_context (group->gimp);      GimpImage    *image    = gimp_context_get_image (context);      GimpDrawable *drawable = NULL;      gboolean      sensitive;      const gchar  *tooltip;      if (image)        drawable = gimp_image_get_active_drawable (image);      sensitive = gimp_procedure_get_sensitive (GIMP_PROCEDURE (proc),                                                GIMP_OBJECT (drawable),                                                &tooltip);      gimp_action_group_set_action_sensitive (group,                                              gimp_object_get_name (proc),                                              sensitive);      if (! sensitive && drawable && tooltip)        gimp_action_group_set_action_tooltip (group,                                              gimp_object_get_name (proc),                                              tooltip);    }}

GtkWidget *gimp_toolbox_image_area_create (GimpToolbox *toolbox,                                gint         width,                                gint         height){  GimpContext *context;  GtkWidget   *image_view;  gchar       *tooltip;  g_return_val_if_fail (GIMP_IS_TOOLBOX (toolbox), NULL);  context = gimp_toolbox_get_context (toolbox);  image_view = gimp_view_new_full_by_types (context,                                            GIMP_TYPE_VIEW, GIMP_TYPE_IMAGE,                                            width, height, 0,                                            FALSE, TRUE, TRUE);  g_signal_connect (image_view, "set-viewable",                    G_CALLBACK (image_preview_set_viewable),                    NULL);  gimp_view_set_viewable (GIMP_VIEW (image_view),                          GIMP_VIEWABLE (gimp_context_get_image (context)));  gtk_widget_show (image_view);#ifdef GDK_WINDOWING_X11  tooltip = g_strdup_printf ("%s/n%s",                             _("The active image./n"                               "Click to open the Image Dialog."),                             _("Drag to an XDS enabled file-manager to "                               "save the image."));#else  tooltip = g_strdup (_("The active image./n"                        "Click to open the Image Dialog."));#endif  gimp_help_set_help_data (image_view, tooltip,                           GIMP_HELP_TOOLBOX_IMAGE_AREA);  g_free (tooltip);  g_signal_connect_object (context, "image-changed",                           G_CALLBACK (gimp_view_set_viewable),                           image_view, G_CONNECT_SWAPPED);  g_signal_connect (image_view, "clicked",                    G_CALLBACK (image_preview_clicked),                    toolbox);  gimp_dnd_viewable_dest_add (image_view,                              GIMP_TYPE_IMAGE,                              image_preview_drop_image,                              context);  return image_view;}

static voidgimp_brush_editor_set_data (GimpDataEditor *editor,                            GimpData       *data){  GimpBrushEditor         *brush_editor = GIMP_BRUSH_EDITOR (editor);  GimpBrushGeneratedShape  shape        = GIMP_BRUSH_GENERATED_CIRCLE;  gdouble                  radius       = 0.0;  gint                     spikes       = 2;  gdouble                  hardness     = 0.0;  gdouble                  ratio        = 0.0;  gdouble                  angle        = 0.0;  gdouble                  spacing      = 0.0;  if (editor->data)    g_signal_handlers_disconnect_by_func (editor->data,                                          gimp_brush_editor_notify_brush,                                          editor);  GIMP_DATA_EDITOR_CLASS (parent_class)->set_data (editor, data);  if (editor->data)    g_signal_connect (editor->data, "notify",                      G_CALLBACK (gimp_brush_editor_notify_brush),                      editor);  gimp_view_set_viewable (GIMP_VIEW (editor->view), GIMP_VIEWABLE (data));  if (editor->data)    {      spacing = gimp_brush_get_spacing (GIMP_BRUSH (editor->data));      if (GIMP_IS_BRUSH_GENERATED (editor->data))        {          GimpBrushGenerated *brush = GIMP_BRUSH_GENERATED (editor->data);          shape    = gimp_brush_generated_get_shape        (brush);          radius   = gimp_brush_generated_get_radius       (brush);          spikes   = gimp_brush_generated_get_spikes       (brush);          hardness = gimp_brush_generated_get_hardness     (brush);          ratio    = gimp_brush_generated_get_aspect_ratio (brush);          angle    = gimp_brush_generated_get_angle        (brush);        }    }  gtk_widget_set_sensitive (brush_editor->options_box,                            editor->data_editable);  gimp_int_radio_group_set_active (GTK_RADIO_BUTTON (brush_editor->shape_group),                                   shape);  gtk_adjustment_set_value (brush_editor->radius_data,       radius);  gtk_adjustment_set_value (brush_editor->spikes_data,       spikes);  gtk_adjustment_set_value (brush_editor->hardness_data,     hardness);  gtk_adjustment_set_value (brush_editor->aspect_ratio_data, ratio);  gtk_adjustment_set_value (brush_editor->angle_data,        angle);  gtk_adjustment_set_value (brush_editor->spacing_data,      spacing);}

static voidgimp_display_shell_dnd_bucket_fill (GimpDisplayShell   *shell,                                    GimpBucketFillMode  fill_mode,                                    const GimpRGB      *color,                                    GimpPattern        *pattern){  GimpImage    *image = gimp_display_get_image (shell->display);  GimpDrawable *drawable;  if (shell->display->gimp->busy)    return;  if (! image)    return;  drawable = gimp_image_get_active_drawable (image);  if (! drawable)    return;  if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable)))    {      gimp_message_literal (shell->display->gimp, G_OBJECT (shell->display),                            GIMP_MESSAGE_ERROR,                            _("Cannot modify the pixels of layer groups."));      return;    }  if (gimp_item_is_content_locked (GIMP_ITEM (drawable)))    {      gimp_message_literal (shell->display->gimp, G_OBJECT (shell->display),                            GIMP_MESSAGE_ERROR,                            _("The active layer's pixels are locked."));      return;    }  /* FIXME: there should be a virtual method for this that the   *        GimpTextLayer can override.   */  if (color && gimp_item_is_text_layer (GIMP_ITEM (drawable)))    {      gimp_text_layer_set (GIMP_TEXT_LAYER (drawable), NULL,                           "color", color,                           NULL);    }  else    {      gimp_edit_fill_full (image, drawable,                           color, pattern,                           GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE,                           pattern ?                           C_("undo-type", "Drop pattern to layer") :                           C_("undo-type", "Drop color to layer"));    }  gimp_display_shell_dnd_flush (shell, image);}