Restore GimpMetadata API - merge with Master

restore xcf-functions
restore file-load/save functions

.dir-locals.el

@@ -0,0 +1,4 @@
+((c-mode . ((c-file-style . "GNU")
+            (c-basic-offset . 2)
+            (indent-tabs-mode . nil)
+            (show-trailing-whitespace . t))))

.kateconfig

@@ -0,0 +1,4 @@
+kate: indent-mode cstyle;
+kate: indent-width 2; tab-width 8;
+kate: tab-indents off; replace-tabs on;
+kate: remove-trailing-spaces modified;

AUTHORS

@@ -70,6 +70,7 @@ The following people have contributed code to GIMP:
  Daniel Eddeland
  Daniel Egger
  Ulf-D. Ehlert
+ Ell
  Morton Eriksen
  Larry Ewing
  Pedro Alonso Ferrer
@@ -209,6 +210,7 @@ The following people have contributed code to GIMP:
  Victor Oliveira
  Thom van Os
  Garry R. Osgood
+ Nathan Osman
  Benjamin Otte
  Petr Ovtchenkov
  Alan Paeth
@@ -275,6 +277,7 @@ The following people have contributed code to GIMP:
  Ian Tester
  Andy Thomas
  Mason Thomas
+ Benoit Touchette
  Patrice Tremblay
  Kevin Turner
  Andreas Turtschan
@@ -315,6 +318,7 @@ The following people have contributed art to GIMP:
  Ville Pätsi
  Mike Schaeffer
  Carol Spears
+ Klaus Staedtler
  Jakub Steiner
  William Szilveszter
 

HACKING

@@ -151,6 +151,12 @@ style is enforced.  The GIMP coding style is defined as follows:
           starting in the first column of the following line. All
           parameters are prototyped and there's a new line for each.
 
+The source tree contains local config files which can be used to set the
+right coding style in common editors: `.dir-locals.el` for Emacs,
+`.kateconfig` for Kate, and `devel-docs/c.vim` for Vim (check the top
+comments to see how to enable it automatically when opening a file in
+the GIMP tree).
+
 Try to make use of GLib's object system as much as possible. Do not
 create wrappers around functions of parent classes. If you end up
 duplicating code, try to create a common parent class and implement

INSTALL.in

@@ -76,19 +76,18 @@ header files installed.
   8. For metadata access GIMP requires the gexiv2 library. It is hosted
      at https://wiki.gnome.org/Projects/gexiv2 .
 
-  9. libpng, libjpeg and lcms are hard dependencies that can not be
+  9. libpng, libjpeg, libtiff and lcms are hard dependencies that can
-     disabled.
+     not be disabled.
 
- 10. For optional mypaint brushes, you should install brushlib (libmypaint) @LIBMYPAINT_REQUIRED_VERSION@,
+ 10. For MyPaint brushes, brushlib (libmypaint) @LIBMYPAINT_REQUIRED_VERSION@ is used.
-     compiled with GEGL support: `scons enable_gegl=true install`.
+     The libmypaint repository is hosted at:
-     Brushlib repository is hosted at:
 
         https://github.com/mypaint/libmypaint
 
  11. You may want to install other third party libraries or programs
      that are needed for some of the available plug-ins. We recommend
      to check that the following libraries are installed: libjasper,
-     libpoppler-glib, libtiff, webkit, libmng, librsvg, libwmf, libaa
+     libpoppler-glib, webkit, libmng, librsvg, libwmf, libaa
      and libgs (Ghostscript).
 
      Note that to be able to render CJK (Asian) and Cyrillic characters
@@ -104,40 +103,49 @@ header files installed.
      or newer) to be present. You will also need PyGTK and the
      respective development headers.
 
- 13. Configure GIMP by running the `configure' script. You may want
+ 13. Windows builds can now generate backtrace logs upon a crash.
+     The logs will be available in: %APPDATA%\GIMP\@GIMP_APP_VERSION@\CrashLog\
+     The feature depends on Dr.MinGW's ExcHndl library:
+
+        https://github.com/jrfonseca/drmingw
+
+ 14. Configure GIMP by running the `configure' script. You may want
      to pass some options to it, see below.
 
- 14. Build GIMP by running `make'. The use of GNU make is recommended.
+ 15. Build GIMP by running `make'. The use of GNU make is recommended.
      If you need to tweak the build to make it work with other flavours
      of make, we'd appreciate if you'd send us a patch with the changes.
 
- 15. Install GIMP by running `make install'. In order to avoid clashes
+ 16. Install GIMP by running `make install'. In order to avoid clashes
      with other versions of GIMP, we install a binary called gimp-@GIMP_APP_VERSION@.
      By default there's also a link created so that you can type 'gimp'
      to start gimp-@GIMP_APP_VERSION@.
 
- 16. Summary of required packages and what version you need:
+ 17. Summary of required packages and what version you need:
 
-     ATK: @ATK_REQUIRED_VERSION@
+     Package Name	Version
-     babl: @BABL_REQUIRED_VERSION@
+
-     libbzip2
+     ATK     		@ATK_REQUIRED_VERSION@
-     cairo: @CAIRO_REQUIRED_VERSION@
+     babl		@BABL_REQUIRED_VERSION@
-     Fontconfig: @FONTCONFIG_REQUIRED_VERSION@
+     cairo 		@CAIRO_REQUIRED_VERSION@
-     freetype2: @FREETYPE2_REQUIRED_VERSION@
+     Fontconfig 	@FONTCONFIG_REQUIRED_VERSION@
-     GDK-PixBuf: @GDK_PIXBUF_REQUIRED_VERSION@
+     freetype2 		@FREETYPE2_REQUIRED_VERSION@
-     GEGL: @GEGL_REQUIRED_VERSION@
+     GDK-PixBuf 	@GDK_PIXBUF_REQUIRED_VERSION@
-     GLib: @GLIB_REQUIRED_VERSION@
+     GEGL 		@GEGL_REQUIRED_VERSION@
-     GTK+: @GTK_REQUIRED_VERSION@
+     GLib 		@GLIB_REQUIRED_VERSION@
-     HarfBuzz: @HARFBUZZ_REQUIRED_VERSION@
+     GTK+ 		@GTK_REQUIRED_VERSION@
+     HarfBuzz 		@HARFBUZZ_REQUIRED_VERSION@
      libbzip2
      libjpeg
-     libpng: @LIBPNG_REQUIRED_VERSION@
+     libpng 		@LIBPNG_REQUIRED_VERSION@
-     liblzma: @LIBLZMA_REQUIRED_VERSION@
+     liblzma 		@LIBLZMA_REQUIRED_VERSION@
-     Little CMS: @LCMS_REQUIRED_VERSION@
+     libmypaint 	@LIBMYPAINT_REQUIRED_VERSION@
-     pangocairo: @PANGOCAIRO_REQUIRED_VERSION@
+     libtiff
+     Little CMS 	@LCMS_REQUIRED_VERSION@
+     pangocairo 	@PANGOCAIRO_REQUIRED_VERSION@
      zlib
 
- 17. Summary of optional packages:
+ 18. Summary of optional packages:
 
      Package Name	Version		Feature
 
@@ -152,12 +160,17 @@ header files installed.
      cairo-pdf		@CAIRO_PDF_REQUIRED_VERSION@		PDF export
      python 2		@PYTHON2_REQUIRED_VERSION@		Python plug-ins
      librsvg		@RSVG_REQUIRED_VERSION@		SVG
-     libtiff		-		TIFF
      libwmf		@WMF_REQUIRED_VERSION@		WMF
      libXcursor		-		X11 Mouse Cursor
      libxpm		-		XPM
-     libmypaint		@LIBMYPAINT_REQUIRED_VERSION@		MyPaint brushes
+     ExcHndl		-		Crash logs on Windows with Dr. MinGW
+     libwebp		@WEBP_REQUIRED_VERSION@		WebP (built with --enable-libwebpmux and --enable-libwebpdemux)
 
+ 19. Summary of optional runtime dependencies:
+
+     darktable >= 1.7, with lua support enabled for raw loading
+     xdg-email for sending emails
+     sendmail for sending emails if --with-sendmail enabled
 
 Please make sure you don't have any old GTK+-2.x, jpeg, etc. libraries
 lying around on your system, otherwise configure may fail to find the
@@ -171,9 +184,9 @@ compilation and installation output is not shown.
 
   % tar xvfz gimp-@GIMP_VERSION@.tar.gz   # unpack the sources
   % cd gimp-@GIMP_VERSION@                # change to the toplevel directory
-  % ./configure                  # run the `configure' script
+  % ./configure                           # run the `configure' script
-  % make                         # build GIMP
+  % make                                  # build GIMP
-  % make install                 # install GIMP
+  % make install                          # install GIMP
 
 
 The `configure' script examines your system, and adapts GIMP to run on
@@ -183,6 +196,9 @@ options can be listed using the command `./configure --help'. There
 are several special options the GIMP `configure' script recognizes.
 These are:
 
+  --enable-vector-icons.  This option installs vector icons instead of
+     raster icons.
+
   --enable-shared and --disable-shared.  This option affects whether
      shared libraries will be built or not. Shared libraries provide
      for much smaller executables. The default is to enable shared
@@ -194,7 +210,7 @@ These are:
      on. The default is for debugging to be disabled. NOTE: This
      option is intended primarily as a convenience for developers.
 
-  --enable-profile and --disable-profile. This options causes the build
+  --enable-profile and --disable-profile. This option causes the build
      process to compile with execution profiling enabled. The default is
      for profiling to be disabled. NOTE: This option is intended primarily
      as a convenience for developers.
@@ -286,9 +302,10 @@ These are:
   --disable-mp. This option allows you to disable support for multiple
      processors. It is enabled by default.
 
-  --with-sendmail=[PATH]. This option is used to tell GIMP where to find
+  --with-sendmail[=PATH]. This option is used to tell GIMP to send email
-     the sendmail command. Normally this options don't have to be used
+     through sendmail instead of xdg-email. You can optionally indicate
-     because configure tries to find it in the usual places.
+     where to find the sendmail command. Otherwise sendmail will simply
+     be searched in your $PATH at runtime.
 
   --with-desktop-dir=[PATH]. This option specifies where to install
      desktop files. These files are used by desktop environments that

Makefile.am

@@ -5,7 +5,6 @@ ACLOCAL_AMFLAGS = -I m4macros ${ACLOCAL_FLAGS}
 SUBDIRS = \
 	m4macros	\
 	cursors		\
-	icons		\
 	themes		\
 	po		\
 	po-libgimp	\
@@ -18,6 +17,7 @@ SUBDIRS = \
 	menus		\
 	libgimpbase	\
 	tools		\
+	icons		\
 	libgimpcolor	\
 	libgimpmath	\
 	libgimpconfig	\
@@ -65,6 +65,7 @@ EXTRA_DIST = \
 	NEWS.pre-2-2		\
 	NEWS.pre-2-4		\
 	NEWS.pre-2-6		\
+	NEWS.pre-2-8		\
 	README			\
 	README.i18n		\
 	authors.dtd		\

NEWS.pre-2-8

@@ -0,0 +1,642 @@
+                   ------------------------------
+                   GNU Image Manipulation Program
+                          Development Branch
+                   ------------------------------
+
+This used to be the development branch that lead to GIMP 2.8.
+
+
+Changes in GIMP 2.8.0
+=====================
+
+
+Core:
+
+ - Add our own GimpOperationBrightnessContrast because GEGL one is different
+
+
+Plug-ins:
+
+ - Fix some GFig rendering issues
+
+
+Source and build system:
+
+ - Depend on Babl 0.1.10, GEGL 0.2.0 and some other new library versions
+
+
+General:
+
+ - Bug fixes
+ - Translation updates
+
+
+Changes in GIMP 2.7.5
+=====================
+
+
+UI:
+
+ - Minor application menu fixes on the Mac
+ - Make the toolbox arbitrarily resizable again
+ - Add axis labels to the dynamics curves to make them more obvious
+ - Fix dockable showing to do the right thing in both MWM and SWM
+ - Fix some glitches in the tool preset UI, like proper sensitivity
+
+
+Core:
+
+ - Restore autoshrink functionality in the rectangle tools
+ - Allow smudge to work with dynamic brushes
+ - Make sure tool presets and tool options are consistent after loading
+ - Add automatic tags for the folders a file lives in
+ - Make the default Quick Mask color configurable
+ - Fix Color Balance so the "range" setting actually makes a difference
+
+
+Plug-ins:
+
+ - Proper toplevel item sorting in the help browser
+ - Use libraries instead of launching programs in file-compressor
+ - Use the Ghostscript library instead of launching ghostscript
+ - Allow to switch off antialiasing when importing from PDF
+ - Embed the page setup in the main print dialog
+ - Port Gfig to cairo
+
+
+Libgimp:
+
+ - Add PDB API to modify a lot of paint and ink options
+
+
+Data:
+
+ - Add a new set of default brushes and tool presets from Ramon Miranda
+
+
+Developer documentation:
+
+ - Update everything including app/ so all functions appear again
+
+
+Source and build system:
+
+ - Remove the unmaintained makefile.msc build system
+ - Explicitly link plug-ins to -lm when needed
+ - Also create .xz tarballs
+
+
+General:
+
+ - Lots of bug fixes
+ - Tons and tons of translation updates
+
+
+Changes in GIMP 2.7.4
+=====================
+
+
+UI:
+
+ - Add a close button to image tabs in single-window mode
+ - Improve the transform tools' undo strings to be more descriptive
+ - Render the layer's "eye" icon in inconsistent state if the layer is
+   visible, but one of its parents isn't
+ - Add proper stacking for canvas items, so things don't hide each other
+ - Make sure single-window-mode and multi-window-mode are always saved
+   consistently in sessionrc
+
+
+Core:
+
+ - Fix "render_image_tile_fault: assertion `tile[4] != NULL' failed"
+   warnings that occurred for some image sizes
+ - Fix attachment of the floating selection when the gegl projection
+   is enabled
+ - Replace heal algorithm with a new one by Jean-Yves Couleaud that
+   works much better
+ - Make resource sub-folders show up in UI as tags, allowing users
+   to easily locate resource collections they may have installed
+ - Fix graphics tablet canvas interaction by moving from
+   gdk_pointer_grab() to gtk_grab_add() for most grabs
+ - Stop using motion hints, they are a concept from the dark ages
+
+
+Libgimp:
+
+ - Add a basic paint dynamics PDB interface
+
+
+Plug-ins:
+
+ - Make writing color space information to BMP files optional
+ - PSD loader now reads and imports working paths
+
+
+Script-Fu:
+
+ - Lots and lots of undeprecations
+
+
+Developer documentation:
+
+ - Add devel-docs/gegl-porting-plan.txt
+
+
+Source and build system:
+
+ - Make git-version.h generation work in shallow git clones
+ - Modernize use of autotools a bit, maintainer-mode and pdbgen
+   are now enabled by default
+
+
+General:
+
+ - Make gimptool install scripts in the correct system-wide directory
+ - Fix lots and lots of stuff found by static code analysis
+
+
+Changes in GIMP 2.7.3
+=====================
+
+
+UI:
+
+ - Use GimpSpinScales instead of scale entries in all dockable widgets
+ - Allow the spin scale to control a range larger than its scale's range
+ - Implement RTL mode in GimpSpinScale
+ - Add lots of tooltips to tool options
+ - Allow to drop more things to the empty image window, and simply
+   create new images from them
+ - Cage tool: allow to add handle to the cage when clicking on an edge
+ - Cage tool: allow to remove selected handles from the cage by hitting delete
+ - Remember column widths in multi-column dock windows
+ - Support starting GIMP in single-window mode
+ - When the brush is shared among paint tools, also share all
+   brush-modifying paint options
+ - Use ALT+number and ALT+Tab shortcuts to navigate between images
+   in both single- and multi-window mode
+ - Make 'Export to' always activatable and fall back to 'Export...' if
+   no export target has been set yet
+ - In single-window mode, add new dockable dialogs to the image window
+   instead of in a new window
+ - When switching on single-window mode, put docks in the image window
+   depending on what side of the window they originally had
+ - When switching off single-window mode, distribute dock windows
+   better
+ - Add a canvas item for the transform grid, fixing a major speed
+   regression, and add the same guides options as in the rectangle tools
+ - Don't unmaximize the single-window mode image window when closing
+   images
+ - Resurrect the "You can drop dockable dialogs here" help string
+   below the toolbox
+ - Make pick-and-move with the Move Tool work for layers in a layer
+   group
+
+
+Core:
+
+ - Add GimpMotionBuffer which abstracts away stroke smoothing behind
+   a simple API and takes it out of GimpDisplayShell
+ - Add a GimpIdTable utility class
+ - Add a GimpDockContainer interface
+ - Add a GimpSessionManaged interface
+ - Add GimpCanvasRectangleGuides which makes the rectangle tool's
+   guides draw properly
+
+
+Libgimp:
+
+ - Make libgimp depend on GdkPixbuf
+ - Add API to create layers from cairo surfaces
+ - Make it impossible to include individual files from any GIMP
+   library. This was always forbidden and designed so it most
+   probably breaks, but now it reliably breaks using #error
+ - Deprecate the "set_sensitive" logic and use g_object_bind_property()
+
+
+Plug-ins:
+
+ - Use poppler's cairo API to load PDFs, the pixbuf API is removed
+ - Port screenshot from GdkPixbuf to cairo
+ - Fix the annoying parser build warnings in imagemap
+ - Add a check-for-deprecated-procedures-in-script-fu make target
+ - Update libpng code to not use deprecated API (file-mng and file-png)
+ - Add an Item class to pygimp
+ - Correct/update some labels and defaults in the JPEG plug-in's save dialog UI
+ - Fix "Bug 596410 - gimp-image-get-filename returns NULL for imported files"
+
+
+Developer documentation:
+
+ - Many updates
+
+
+Source and build system:
+
+ - Make cairo a global dependency, starting at libgimpcolor
+ - Require poppler >= 0.12.4
+ - Remove gimp-remote for good, it has been disabled for years
+
+
+General:
+
+ - Some more undeprecations now that we use GTK+ 2.24
+ - Fix lots of warnings that are new in -Wall in GCC 4.6
+ - Lots of bug fixes and cleanup
+ - Lots of translation updates
+
+
+Changes in GIMP 2.7.2
+=====================
+
+
+UI:
+
+ - A lot of undeprecations due to GTK+ 2.22 and 2.24
+ - Lots and lots of cairo porting, calls to gdk_draw_* are gone
+ - Merge the cage transform tool from GSoC
+ - Remove the old bitmap cursors completely and always use RGBA cursors
+   also for compat cursors for old X servers
+ - Add new GimpCanvasItem infrastructure with subclasses for everything
+   that needs to be drawn on the canvas and port all tools to canvas items,
+   this is a huge change that touches all tools and almost all display
+   code, and which finally gets rid of XOR drawing altogether
+ - Switch from purely idle-rendering the display to something that ensures
+   a minimum framerate, so we don't fail to update under heavy load
+ - Make the text tool handle RTL mode better
+ - Change GimpColorMapEditor to use the newly added proxy GimpPalette
+ - Replace the brush scale control in tool options by a brush size
+   one that works in pixels, and does the right thing when the brush
+   changes
+ - Add new widget GimpSpinScale which is a scale with number entry,
+   and use it in all tool options
+ - Make the brush, pattern etc. selectors in tool options more
+   compact and allow to directly jump to the editor dialogs
+ - Make handle sizes in tools consistent
+ - Add an on-canvas progress and use it for tool progress instead of
+   the statusbar
+ - Add a new GimpToolPalette class with lots of code that was
+   in GimpToolBox
+ - Allow to properly drop into and after a layer group
+ - Refactor and clean up the dynamics editor widget, and add colors
+   for the curves
+ - Add support for F2 to rename items in lists
+ - Clean up GimpDeviceStatus internally and visually
+ - Allow to set GimpToolPreset's icon using the new GimpIconPicker widget
+ - Make the text tool's style overlay show default values from the
+   text object if there is no style active at the cursor position/selection
+ - Show the the text size's unit in the text style overlay
+ - Make tool dialogs transient to the image window again
+ - Consistently add a "gimp-" prefix to all window roles
+ - Make the preset buttons in tool options work on the global tool
+   presets instead of the removed per-tool preset lists
+ - Add GimpControllerMouse, which allows to bind extra mouse buttons to
+   arbitrary actions
+
+
+Core:
+
+ - Add uniform API to turn any GimpItem's outline into a selection
+ - Add support for color tags in text layers
+ - Remove the selection_control() stuff from GimpImage and with it
+   maybe last piece of UI code still not properly separated
+ - Add more validation code for XCF loading
+ - Add accessors to GimpPalette and use them globally
+ - Keep a proxy GimpPalette around for the image's colormap
+ - Don't scale SVGs when pasting or importing them
+ - A lot of changes to the input device handling code, partly
+   merged from the gtk3-port branch, add GimpDeviceManager class
+ - Add smoothing of paint strokes
+ - Fix display filters to work on a cairo surface
+ - Fix and enhance GimpImage's URI/filename handling API
+ - Unset "removed" flag on items when they get added back to
+   the image from the undo stack
+ - Change item creation to properly use GObject properties and
+   remove item_configure() and drawable_configure()
+ - Refactor tool event handling and move lots of stuff into
+   utility functions
+ - Clean up GimpViewRenderer API
+ - Implement transforms on group layers
+ - Clean up the transform tool a lot, and refactor away old junk
+ - Tool and tool event cleanup: enforce tool activate/halt invariants,
+   consistently shutdown all tools in control(HALT), and many other
+   tool fixes
+ - Remove GimpToolPresets object, this functionality got merged into
+   the new GimpToolPreset system
+ - Rename GimpFilteredContainer to GimpTaggedContainer and add a new
+   GimpFilteredContainer parent class which is a generic filter
+ - Remove the concept of an "offset" from TileManager and instead
+   pass around the offsets explicitly when needed, like when
+   transforming
+ - Move GimpBezier desc from vectors/ to core/ and add API to create
+   one from sorted BoundSegs
+ - Change GimpBrush boundary API to return a GimpBezierDesc
+ - Add GimpBrushCache object and use it to cache a brush's transformed
+   pixels and its outline, remove the caching code from GimpBrushCore
+ - Add GimpBezierDesc based API to GimpScanConvert and use it
+
+
+GEGL:
+
+ - Add operations and gegl infrastructure for the cage tool
+ - Disable View -> Use GEGL as we will not have time to finish the
+   GEGL projection code for GIMP 2.8
+
+
+Libgimp:
+
+ - Introduce an "item" type in the PDB and libgimp and deprecate
+   lots of old API in favor of item API
+ - Add procedures to create, traverse and manipulate layer trees
+ - Add more state to the context API, and deprecate functions with
+   too many parameters in favor of simpler ones that use context states,
+   particularly the entire transform and selection API
+ - Move GimpUnitStore and GimpUnitComboBox to libgimpwidgets, and
+   use them in GimpSizeEntry, deprecate GimpUnitMenu.
+ - Deprecate gimp_min_colors() and gimp_install_cmap()
+ - Add API that enables GimpRuler to track motion events by itself
+ - Add new selection API and deprecate all old selection functions
+ - Move around and rename all parasite functions, deprecate the old ones
+ - Add a generated PDB file in the "gimp" namespace and get rid
+   of "gimpmisc"
+ - Add unit conversion functions to libgimpbase
+ - Add function to reset a plug-in's context to default values
+
+
+Plug-ins:
+
+ - Make script-fu server IPv6 aware
+ - Follow libgimp deprecations in plug-ins and scripts
+ - Add PDF export plugin
+ - Lots of cairo porting here too
+ - UTF-8 fixes in script-fu
+ - Set the progress to 1.0 when done
+ - Merge a lot of upstream fixes into script-fu's Tinyscheme
+ - Add "New Layer" option to MapObject
+ - Support loading of 16-bit raw PPM files
+ - Add web-page, a new plug-in which renders images of web pages
+ - Fix some more plug-ins to not warn if applied on an empty region
+
+
+Data:
+
+ - Remove "Untitled" from palette names entries
+
+
+Developer documentation:
+
+ - Move libgimp documentation from templates to inline comments
+ - Generate standard deprecated sections
+
+
+Source and build system:
+
+ - Add more code documentation
+ - Add more unit tests and refactor existing ones to use global
+   test utility functions
+ - Add a manifest to executables (app and plug-ins, Win32)
+ - Depend on GLib 2.28, GTK+ 2.24, Cairo 1.10
+ - Make WebKit available to all plug-ins, not just the help browser
+ - Run UI tests on Xvfb if available
+ - Check for GdkPixbuf separately because it's now a separate library
+ - Allow tests to use uninstalled plug-ins from the build dir
+ - Remove, comment out, or build for GIMP_UNSTABLE some stuff that
+   should not be in a stable release
+
+
+General:
+
+ - Improve safety on Win32 by calling SetDllDirectory() and
+   SetProcessDEPPolicy()
+ - Switch from GtkObject::destroy() to GObject::dispose() all over
+   the place
+ - Various changes that make maintaining the gtk3-port branch easier,
+   such as s/GtkAnchorType/GimpHandleAnchor/ and s/GtkObject/GtkAdjustment/
+ - Don't use gtk_container_add() for adding to GtkBoxes
+ - Inherit from GtkBox directly, not from GtkHBox/GtkVBox
+ - Add namespace to the ink blob types and functions
+ - Remove all useless calls to gtk_range_set_update_policy()
+ - Use GObject::constructed() instead of GObject::constructor() all
+   over the place
+ - Move more members to private and add accessors for them
+ - Stop using GdkNativeWindow, use guint32 instead
+ - Plug memory leaks
+ - Remove ps-menurc, we are not a PS clone
+ - Use the new g_[s]list_free_full() instead of foreach() and free()
+ - Don't use newly deprecated GTK+ API
+ - Use the new GDK_KEY_foo key names
+ - Lots of bug fixes and cleanup
+ - Lots of translation updates
+
+
+Changes in GIMP 2.7.1
+=====================
+
+
+UI:
+
+ - Add "lock content" button to the layers, channels and paths dialogs,
+   make the lock buttons more compact
+ - Refuse to edit locked items
+ - Add support for layer groups
+ - Improve internals and GUI of the save/export functionality
+ - Move the shortcut dialog's "clear" button into the entry
+ - Clean up UI code by introducing GimpDockWindow and GimpImageWindow
+   classes
+ - Support multi-column dock windows
+ - Get rid of docking bars, use highlights in existing widget hierarchy instead
+ - Remove toolbox-window-hint gimprc setting and use dock-window-hint
+   for both toolbox and docks instead
+ - Move GimpDock::default-height style property to GimpDockWindow
+ - Polish save+export path-part precedence rules
+ - Merge the GSoC 2009 Advanced GUI for Brush Dynamics project
+ - Default to non-fixed-aspect in Canvas Size dialog
+ - Add a still incomplete and Single-window mode
+ - Have an Export button, not Save, in export dialogs
+ - Improve Free Select Tool handle highlighting
+ - Support changing user interface language from preferences
+ - Update ps-menurc with PS CS4 keyboard shortcuts
+ - Reduce spacing around canvas and use it for the canvas itself
+ - Put name of active dockables in dock window titles
+ - Don't have Toolbox in list of Recently Closed Docks, handle that
+   directly in the Windows menu
+ - Support selecting and tagging multiple objects in resource lists
+ - Improve on-canvas text editing and text attribute setting
+ - Add GimpContainerTreeStore and use it in all GtkTreeStore based views
+ - Add a new default "automatic" tab style that makes sure dockable tabs
+   always show as much detail as possible
+ - Remove the dockable title bar and add the menu arrow button next to the
+   notebook tabs
+ - Add an icon for the desaturate tool
+ - Add 'Rule of fifths' crop guide overlay
+ - Make Alt+Click on layers not affect active layer
+
+
+Core:
+
+ - Make all GimpItems lockable so their contents can't be changed
+ - Make more sense when naming imported layers
+ - Make group layers work except for layer masks and save them in
+   the XCF
+ - Change GimpProjectable::update to GimpProjectable:invalidate
+ - Make sure we don't mix font backends (and crash) by explicitly
+   asking for FT/Fontconfig backends
+ - Move members of GimpObject to a private struct
+ - gimp_object_get_name() takes a gconstpointer now, remove casts
+   from all callers
+ - Let drawables connect to their floating selection's "update" signal
+   instead of letting the image do this job
+ - Fix brush rotation artifacts at even 90 degree rotation
+ - Don't leak shared tile memory on Solaris
+ - Add a PDB procedure to access a text layer's markup
+ - Remove legacy cruft from pdbgen and make sure number ranges are correct
+ - Move all image creation functions to a common file
+ - Add translation context to all undo descriptions
+
+
+GEGL:
+
+ - Make sure all nodes are added to their resp. graphs
+ - Use GEGL for layer scaling if use-gegl is TRUE
+
+
+Plug-ins:
+
+ - Updated script-fu's scheme to latest upstream fixes
+ - Don't store image-specific print settings globally
+ - Add fundamental OpenRaster (.ora) import and export support
+ - Add RGB565 support to the csource plug-in
+
+
+Data:
+
+ - Add texture/grunge brushes made by Johannes Engelhardt
+
+
+Developer documentation:
+
+ - Explain GimpContext
+ - Add SVG graphic with GIMP application core module dependencies
+ - Add a schedule for 2.8 development
+
+
+Source and build system:
+
+ - Add more code documentation
+ - Clean up subsystem linking dependencies in app/
+ - Add unit testing framework in app/tests/ and some basic tests,
+   including basic UI tests and XCF tests
+ - Tentatively introduce usage of using Glade + GtkBuilder
+ - Depend on GLib 2.24.0 and GTK+ 2.20.0
+ - Add git commit hash in --verbose --version output
+ - Don't version control gtk-doc.m4, get it from gtkdocize
+ - Add GimpObject tracking code
+ - Plug memory leaks
+ - Lots of bug fixes and cleanup
+ - Lots of translation updates
+
+
+Changes in GIMP 2.7.0
+=====================
+
+UI:
+ - Change the Text Tool to perform text editing on-canvas (GSoC 2008)
+   and add the ability to mix different text styles in the same layer
+ - Add support for tagging GIMP resources such as brushes and allow
+   filtering based on these tags (GSoC 2008)
+ - Separate the activities of saving an image and exporting it, there is
+   now a 'File->Export...' for example
+ - Port file plug-ins to new export API which gets rid of many
+   annoying export dialogs
+ - Add a simple parser to size entry widgets, images can be scaled
+   to e.g. "50%" or "2 * 37px + 10in"
+ - Arrange layer modes into more logical and useful groups
+ - Added support for rotation of brushes
+ - Make the Pointer dockable show information about selection position
+   and size
+ - Get rid of the Tools dockable and move toolbox configuration to
+   Preferences
+ - Allow closing the toolbox without closing the whole application
+ - Add status bar feedback for keyboard changes to brush parameters
+ - Add diagonal guides to the Crop Tool
+ - New docks are created at the pointer position
+ - Add support for printing crop marks for images
+ - Move 'Text along path' from tool options to text context menu
+ - Change default shortcuts for "Shrink Wrap" and "Fit in Window" to
+   Ctrl+J and Ctrl+Shift+J respectively since the previous shortcuts
+   are now used for the save+export feature
+ - Make Alt+Click on layers in Layers dockable create a selection from
+   the layer
+ - Allow to specify written language in the Text Tool
+ - Support custom mapping curves for input device properties like "Pressure"
+ - New desktop launcher icon
+ - Add 'Windows→Hide docks' menu item that does what 'Tab' does and also displays
+   its state. Make the state persistent across sessions, too.
+ - Make dock window title separators translatable
+
+
+Plug-ins:
+
+ - Map the 'Linear Dodge' layer mode in PSD files to the 'Addition'
+   layer mode in GIMP
+ - Add JPEG2000 load plug-in
+ - Add X11 mouse cursor plug-in
+ - Add support for loading 16bit (RGB565) raw data
+ - Add palette exporter for CSS, PHP, Python, txt and Java, accessed
+   through palette context menu
+ - Add plug-in API for getting image URI, for manipulating size of
+   text layers, for getting and setting text layer hint, and for
+   unified export dialog appearance
+ - Add an 'As Animation' toggle to the GIF export options
+ - Add 'active_vectors' getsetter to Python 'gimp.Image'
+
+
+Data:
+
+ - Add large variants of round brushes and remove duplicate and
+   useless brushes
+ - Add "FG to BG (Hardedge)" gradient
+
+
+GEGL:
+
+ - Port the projection code, the code that composes a single image
+   from a stack of layers, to GEGL
+ - Port layer modes to GEGL
+ - Port the floating selection code to GEGL
+ - Refactor the layer stack code to prepare for layer groups later
+ - Prepare better and more intuitive handling of the floating
+   selection
+ - Add File->Debug->Show Image Graph that show the GEGL graph of an
+   image
+ - Allow to benchmark projection performance with
+   File->Debug->Benchmark Projection
+ - When using GEGL for the projection, use CIELCH instead of HSV/HSL
+   for color based layer modes
+
+
+Core:
+
+ - Make painting strokes Catmull-Rom Spline interpolated
+ - Add support for arbitrary affine transforms of brushes
+ - Add support for brush dynamics to depend on tilt
+ - Add aspect ratio to brush dynamics
+ - Add infrastructure to soon support vector layers (GSoC 2006)
+ - Rearrange legacy layer mode code to increase maintainability
+ - Drop support for the obsolete GnomeVFS file-uri backend
+ - Allow to dump keyboard shortcuts with File->Debug->Dump Keyboard
+   Shortcuts
+ - Prepare data structures for layer groups
+ - Remove gimprc setting "menu-mnemonics",
+   "GtkSettings:gtk-enable-mnemonics" shall be used instead
+ - Remove "transient-docks" gimprc setting, the 'Utility window' hint
+   and a sane window manager does a better job
+ - Remove "web-browser" gimprc setting and use gtk_show_uri() instead
+
+
+General:
+
+ - Changed license to (L)GPLv3+
+ - Use the automake 1.11 feature 'silent build rules' by default
+ - Lots of bug fixes and cleanup

README

@@ -1,13 +1,18 @@
                    ------------------------------
                    GNU Image Manipulation Program
-                         2.8 Stable Branch
+                       2.9 Development Branch
                    ------------------------------
 
-GIMP 2.8 replaces earlier GIMP 2.x versions. It is advised that you
+This is an unstable development release, an intermediate state on the
-uninstall them before installing GIMP 2.8. If you want to keep your
+way to the next stable release 2.10. GIMP 2.9 may or may not do what
-older GIMP 2.x installation in parallel to GIMP 2.8, you have to
+you expect. Save your work early and often. If you want a stable
+version, please use GIMP 2.8 instead.
+
+GIMP 2.9 replaces earlier GIMP 2.x versions. It is advised that you
+uninstall them before installing GIMP 2.9. If you want to keep your
+older GIMP 2.x installation in parallel to GIMP 2.9, you have to
 choose a separate prefix which is not in your default library search
-path. Otherwise your prevoius GIMP installation will start to use the
+path. Otherwise your previous GIMP installation will start to use the
 new libraries. You have been warned.
 
 If you think you found a bug in this version, please make sure that it
@@ -52,9 +57,12 @@ Links to several archives of the mailing lists are included in that page.
 
 Gimp-user-list is a mailing list dedicated to user problems, hints and
 tips, discussion of cool effects, etc.  Gimp-developer-list is oriented
-to GIMP core and plug-in developers.  Most people will only want to be
+to GIMP core and plug-in developers.  Gimp-gui-list is for discussing
-subscribed to gimp-user-list. If you want to help develop GIMP, the
+about GIMP interface to improve user experience. Most people will only
-gimp-developer mailing list is a good starting point.
+want to be subscribed to gimp-user-list. If you want to help develop
+GIMP, the gimp-developer mailing list is a good starting point; if you
+want to help with GUI design, the gimp-gui list is where you want to
+subscribe.
 
 
 3. IRC
@@ -77,12 +85,12 @@ The look of GIMP's interface can be customized like any other GTK app
 by editing the ~/.gtkrc-2.0 file or by using "themes" (ready-made
 customizations).  For downloadable themes and further details, see
 http://art.gnome.org/themes/gtk2 . Additionally, GIMP reads the file
-~/.config/GIMP/2.8/gtkrc so you can have settings that only apply to GIMP.
+~/.config/GIMP/2.9/gtkrc so you can have settings that only apply to GIMP.
 
 Included is a set of keybindings similar to those in Adobe Photoshop.
 You can find them in the ps-menurc file.  To use them, copy this file
-to ~/.config/GIMP/2.8/menurc. You can also manually change the keybindings to
+to ~/.config/GIMP/2.9/menurc. You can also manually change the keybindings to
-any of your choice by editing ~/.config/GIMP/2.8/menurc.
+any of your choice by editing ~/.config/GIMP/2.9/menurc.
 
 
 Have fun,

app/Makefile.am

@@ -47,8 +47,6 @@ libapp_sources = \
 	about.h			\
 	app.c			\
 	app.h			\
-	batch.c			\
-	batch.h			\
 	errors.c		\
 	errors.h		\
 	language.c		\
@@ -61,8 +59,6 @@ libapp_sources = \
 	tests.h			\
 	unique.c		\
 	unique.h		\
-	units.c			\
-	units.h			\
 	version.c		\
 	version.h		\
 	gimp-debug.c		\
@@ -94,6 +90,11 @@ endif
 
 if OS_WIN32
 win32_ldflags = -mwindows -Wl,--tsaware $(WIN32_LARGE_ADDRESS_AWARE)
+
+if HAVE_EXCHNDL
+exchndl = -lexchndl
+endif
+
 else
 libm = -lm
 endif
@@ -109,12 +110,15 @@ GIMPCONSOLERC = gimp-console-$(GIMP_APP_VERSION).rc.o
 endif
 
 AM_CPPFLAGS = \
+	-DGIMPDIR=\""$(gimpdir)"\"				\
+	-DGIMP_USER_VERSION=\"$(GIMP_USER_VERSION)\"		\
 	-DG_LOG_DOMAIN=\"Gimp\"		\
 	-DGIMP_APP_GLUE_COMPILATION	\
 	-I$(top_srcdir)			\
 	$(GTK_CFLAGS)			\
 	$(PANGOCAIRO_CFLAGS)		\
 	$(GEGL_CFLAGS)			\
+	$(LCMS_CFLAGS)			\
 	$(GEXIV2_CFLAGS)		\
 	-I$(includedir)			\
 	-I$(builddir)/gui
@@ -160,11 +164,11 @@ gimpconsoleldadd = \
 	$(GIO_WINDOWS_LIBS)		\
 	$(GEGL_LIBS)			\
 	$(GLIB_LIBS)			\
-	$(GEXIV2_LIBS)			\
 	$(LCMS_LIBS)			\
+	$(GEXIV2_LIBS)			\
 	$(Z_LIBS)			\
 	$(JSON_C_LIBS)			\
-	$(LIBMYPAINTGEGL_LIBS)		\
+	$(LIBMYPAINT_LIBS)		\
 	$(INTLLIBS)			\
 	$(RT_LIBS)			\
 	$(libm)
@@ -188,6 +192,7 @@ gimp_@GIMP_APP_VERSION@_LDADD = \
 	$(GTK_MAC_INTEGRATION_LIBS)	\
 	$(DBUS_GLIB_LIBS)		\
 	$(gimpconsoleldadd)		\
+	$(exchndl)			\
 	$(GIMPRC)
 
 

app/about.h

@@ -30,6 +30,11 @@
   _("Copyright © 1995-%s\n" \
     "Spencer Kimball, Peter Mattis and the GIMP Development Team")
 
+/* TRANSLATORS: do not end the license URL with a dot, because it would
+ * be in the link. Because of technical limitations, make sure the URL
+ * ends with a space, a newline or is end of text.
+ * Cf. bug 762282.
+ */
 #define GIMP_LICENSE \
   _("GIMP is free software: you can redistribute it and/or modify it "   \
     "under the terms of the GNU General Public License as published by " \
@@ -42,7 +47,7 @@
     "GNU General Public License for more details."                       \
     "\n\n"                                                               \
     "You should have received a copy of the GNU General Public License " \
-    "along with GIMP.  If not, see http://www.gnu.org/licenses/.")
+    "along with GIMP. If not, see: http://www.gnu.org/licenses/")
 
 
 #endif /* __ABOUT_H__ */

app/actions/Makefile.am

@@ -17,6 +17,9 @@ libappactions_a_SOURCES = \
 	actions.c			\
 	actions.h			\
 	\
+	gimpgeglprocedure.c		\
+	gimpgeglprocedure.h		\
+	\
 	brush-editor-actions.c		\
 	brush-editor-actions.h		\
 	brushes-actions.c		\
@@ -113,10 +116,16 @@ libappactions_a_SOURCES = \
 	images-actions.h		\
 	images-commands.c		\
 	images-commands.h		\
+	items-commands.c		\
+	items-commands.h		\
+	items-actions.c			\
+	items-actions.h			\
 	layers-actions.c		\
 	layers-actions.h		\
 	layers-commands.c		\
 	layers-commands.h		\
+	mypaint-brushes-actions.c	\
+	mypaint-brushes-actions.h	\
 	palette-editor-actions.c	\
 	palette-editor-actions.h	\
 	palette-editor-commands.c	\
@@ -131,6 +140,8 @@ libappactions_a_SOURCES = \
 	plug-in-actions.h		\
 	plug-in-commands.c		\
 	plug-in-commands.h		\
+	procedure-commands.c		\
+	procedure-commands.h		\
 	quick-mask-actions.c		\
 	quick-mask-actions.h		\
 	quick-mask-commands.c		\
@@ -161,8 +172,12 @@ libappactions_a_SOURCES = \
 	tool-options-commands.h		\
 	tool-presets-actions.c		\
 	tool-presets-actions.h		\
+	tool-presets-commands.c		\
+	tool-presets-commands.h		\
 	tool-preset-editor-actions.c	\
 	tool-preset-editor-actions.h	\
+	tool-preset-editor-commands.c	\
+	tool-preset-editor-commands.h	\
 	tools-actions.c			\
 	tools-actions.h			\
 	tools-commands.c		\

app/actions/actions.c

@@ -76,6 +76,7 @@
 #include "image-actions.h"
 #include "images-actions.h"
 #include "layers-actions.h"
+#include "mypaint-brushes-actions.h"
 #include "palette-editor-actions.h"
 #include "palettes-actions.h"
 #include "patterns-actions.h"
@@ -163,7 +164,7 @@ static const GimpActionFactoryEntry action_groups[] =
   { "filters", N_("Filters"), GIMP_STOCK_GEGL,
     filters_actions_setup,
     filters_actions_update },
-  { "fonts", N_("Fonts"), GIMP_STOCK_FONT,
+  { "fonts", N_("Fonts"), "gtk-select-font",
     fonts_actions_setup,
     fonts_actions_update },
   { "gradient-editor", N_("Gradient Editor"), GIMP_STOCK_GRADIENT,
@@ -190,6 +191,9 @@ static const GimpActionFactoryEntry action_groups[] =
   { "layers", N_("Layers"), GIMP_STOCK_LAYER,
     layers_actions_setup,
     layers_actions_update },
+  { "mypaint-brushes", N_("MyPaint Brushes"), GIMP_STOCK_MYPAINT_BRUSH,
+    mypaint_brushes_actions_setup,
+    mypaint_brushes_actions_update },
   { "palette-editor", N_("Palette Editor"), GIMP_STOCK_PALETTE,
     palette_editor_actions_setup,
     palette_editor_actions_update },
@@ -531,7 +535,7 @@ action_select_value (GimpActionSelectType  select_type,
         value = max - (min - value);
 
       while (value > max)
-        value = min + (max - value);
+        value = min + (value - max);
     }
   else
     {

app/actions/brushes-actions.c

@@ -67,7 +67,7 @@ static const GimpActionEntry brushes_actions[] =
     G_CALLBACK (data_copy_location_cmd_callback),
     GIMP_HELP_BRUSH_COPY_LOCATION },
 
-  { "brushes-show-in-file-manager", "gtk-directory",
+  { "brushes-show-in-file-manager", GIMP_STOCK_FILE_MANAGER,
     NC_("brushes-action", "Show in _File Manager"), NULL,
     NC_("brushes-action", "Show brush file location in the file manager"),
     G_CALLBACK (data_show_in_file_manager_cmd_callback),

app/actions/buffers-actions.c

@@ -54,11 +54,17 @@ static const GimpActionEntry buffers_actions[] =
     G_CALLBACK (buffers_paste_into_cmd_callback),
     GIMP_HELP_BUFFER_PASTE_INTO },
 
-  { "buffers-paste-as-new", GIMP_STOCK_PASTE_AS_NEW,
+  { "buffers-paste-as-new-layer", GIMP_STOCK_PASTE_AS_NEW,
+    NC_("buffers-action", "Paste Buffer as New _Layer"), NULL,
+    NC_("buffers-action", "Paste the selected buffer as a new layer"),
+    G_CALLBACK (buffers_paste_as_new_layer_cmd_callback),
+    GIMP_HELP_BUFFER_PASTE_AS_NEW_LAYER },
+
+  { "buffers-paste-as-new-image", GIMP_STOCK_PASTE_AS_NEW,
     NC_("buffers-action", "Paste Buffer as _New"), NULL,
     NC_("buffers-action", "Paste the selected buffer as a new image"),
-    G_CALLBACK (buffers_paste_as_new_cmd_callback),
+    G_CALLBACK (buffers_paste_as_new_image_cmd_callback),
-    GIMP_HELP_BUFFER_PASTE_AS_NEW },
+    GIMP_HELP_BUFFER_PASTE_AS_NEW_IMAGE },
 
   { "buffers-delete", "edit-delete",
     NC_("buffers-action", "_Delete Buffer"), NULL,
@@ -89,10 +95,11 @@ buffers_actions_update (GimpActionGroup *group,
 #define SET_SENSITIVE(action,condition) \
         gimp_action_group_set_action_sensitive (group, action, (condition) != 0)
 
-  SET_SENSITIVE ("buffers-paste",        buffer);
+  SET_SENSITIVE ("buffers-paste",              buffer);
-  SET_SENSITIVE ("buffers-paste-into",   buffer);
+  SET_SENSITIVE ("buffers-paste-into",         buffer);
-  SET_SENSITIVE ("buffers-paste-as-new", buffer);
+  SET_SENSITIVE ("buffers-paste-as-new-layer", buffer);
-  SET_SENSITIVE ("buffers-delete",       buffer);
+  SET_SENSITIVE ("buffers-paste-as-new-image", buffer);
+  SET_SENSITIVE ("buffers-delete",             buffer);
 
 #undef SET_SENSITIVE
 }

app/actions/buffers-commands.c

@@ -47,7 +47,7 @@
 /*  local function prototypes  */
 
 static void   buffers_paste (GimpBufferView *view,
-                             gboolean        paste_into);
+                             GimpPasteType   paste_type);
 
 
 /*  public functionss */
@@ -56,19 +56,26 @@ void
 buffers_paste_cmd_callback (GtkAction *action,
                             gpointer   data)
 {
-  buffers_paste (GIMP_BUFFER_VIEW (data), FALSE);
+  buffers_paste (GIMP_BUFFER_VIEW (data), GIMP_PASTE_TYPE_FLOATING);
 }
 
 void
 buffers_paste_into_cmd_callback (GtkAction *action,
                                  gpointer   data)
 {
-  buffers_paste (GIMP_BUFFER_VIEW (data), TRUE);
+  buffers_paste (GIMP_BUFFER_VIEW (data), GIMP_PASTE_TYPE_FLOATING_INTO);
 }
 
 void
-buffers_paste_as_new_cmd_callback (GtkAction *action,
+buffers_paste_as_new_layer_cmd_callback (GtkAction *action,
-                                   gpointer   data)
+                                         gpointer   data)
+{
+  buffers_paste (GIMP_BUFFER_VIEW (data), GIMP_PASTE_TYPE_NEW_LAYER);
+}
+
+void
+buffers_paste_as_new_image_cmd_callback (GtkAction *action,
+                                         gpointer   data)
 {
   GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
   GimpContainer       *container;
@@ -108,7 +115,7 @@ buffers_delete_cmd_callback (GtkAction *action,
 
 static void
 buffers_paste (GimpBufferView *view,
-               gboolean        paste_into)
+               GimpPasteType   paste_type)
 {
   GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (view);
   GimpContainer       *container;
@@ -146,7 +153,8 @@ buffers_paste (GimpBufferView *view,
       if (image)
         {
           gimp_edit_paste (image, gimp_image_get_active_drawable (image),
-                           buffer, paste_into, x, y, width, height);
+                           GIMP_OBJECT (buffer), paste_type,
+                           x, y, width, height);
 
           gimp_image_flush (image);
         }

app/actions/buffers-commands.h

@@ -19,14 +19,16 @@
 #define __BUFFERS_COMMANDS_H__
 
 
-void   buffers_paste_cmd_callback        (GtkAction *action,
+void   buffers_paste_cmd_callback              (GtkAction *action,
-                                          gpointer   data);
+                                                gpointer   data);
-void   buffers_paste_into_cmd_callback   (GtkAction *action,
+void   buffers_paste_into_cmd_callback         (GtkAction *action,
-                                          gpointer   data);
+                                                gpointer   data);
-void   buffers_paste_as_new_cmd_callback (GtkAction *action,
+void   buffers_paste_as_new_layer_cmd_callback (GtkAction *action,
-                                          gpointer   data);
+                                                gpointer   data);
-void   buffers_delete_cmd_callback       (GtkAction *action,
+void   buffers_paste_as_new_image_cmd_callback (GtkAction *action,
-                                          gpointer   data);
+                                                gpointer   data);
+void   buffers_delete_cmd_callback             (GtkAction *action,
+                                                gpointer   data);
 
 
 #endif /* __BUFFERS_COMMANDS_H__ */

app/actions/channels-actions.c

@@ -34,6 +34,7 @@
 #include "actions.h"
 #include "channels-actions.h"
 #include "channels-commands.h"
+#include "items-actions.h"
 
 #include "gimp-intl.h"
 
@@ -44,6 +45,10 @@ static const GimpActionEntry channels_actions[] =
     NC_("channels-action", "Channels Menu"), NULL, NULL, NULL,
     GIMP_HELP_CHANNEL_DIALOG },
 
+  { "channels-color-tag-menu", GIMP_STOCK_CLOSE /* abused */,
+    NC_("channels-action", "Color Tag"), NULL, NULL, NULL,
+    GIMP_HELP_CHANNEL_COLOR_TAG },
+
   { "channels-edit-attributes", "gtk-edit",
     NC_("channels-action", "_Edit Channel Attributes..."), NULL,
     NC_("channels-action", "Edit the channel's name, color and opacity"),
@@ -102,6 +107,90 @@ static const GimpActionEntry channels_actions[] =
     GIMP_HELP_CHANNEL_LOWER_TO_BOTTOM }
 };
 
+static const GimpToggleActionEntry channels_toggle_actions[] =
+{
+  { "channels-visible", GIMP_STOCK_VISIBLE,
+    NC_("channels-action", "_Visible"), NULL, NULL,
+    G_CALLBACK (channels_visible_cmd_callback),
+    FALSE,
+    GIMP_HELP_CHANNEL_VISIBLE },
+
+  { "channels-linked", GIMP_STOCK_LINKED,
+    NC_("channels-action", "_Linked"), NULL, NULL,
+    G_CALLBACK (channels_linked_cmd_callback),
+    FALSE,
+    GIMP_HELP_CHANNEL_LINKED },
+
+  { "channels-lock-content", NULL /* GIMP_STOCK_LOCK */,
+    NC_("channels-action", "L_ock pixels"), NULL, NULL,
+    G_CALLBACK (channels_lock_content_cmd_callback),
+    FALSE,
+    GIMP_HELP_CHANNEL_LOCK_PIXELS },
+
+  { "channels-lock-position", GIMP_STOCK_TOOL_MOVE,
+    NC_("channels-action", "L_ock position"), NULL, NULL,
+    G_CALLBACK (channels_lock_position_cmd_callback),
+    FALSE,
+    GIMP_HELP_CHANNEL_LOCK_POSITION }
+};
+
+static const GimpEnumActionEntry channels_color_tag_actions[] =
+{
+  { "channels-color-tag-none", GIMP_STOCK_CLOSE /* abused */,
+    NC_("channels-action", "None"), NULL,
+    NC_("channels-action", "Clear color tag"),
+    GIMP_COLOR_TAG_NONE, FALSE,
+    GIMP_HELP_CHANNEL_COLOR_TAG },
+
+  { "channels-color-tag-blue", NULL,
+    NC_("channels-action", "Blue"), NULL,
+    NC_("channels-action", "Set color tag to blue"),
+    GIMP_COLOR_TAG_BLUE, FALSE,
+    GIMP_HELP_CHANNEL_COLOR_TAG },
+
+  { "channels-color-tag-green", NULL,
+    NC_("channels-action", "Green"), NULL,
+    NC_("channels-action", "Set color tag to green"),
+    GIMP_COLOR_TAG_GREEN, FALSE,
+    GIMP_HELP_CHANNEL_COLOR_TAG },
+
+  { "channels-color-tag-yellow", NULL,
+    NC_("channels-action", "Yellow"), NULL,
+    NC_("channels-action", "Set color tag to yellow"),
+    GIMP_COLOR_TAG_YELLOW, FALSE,
+    GIMP_HELP_CHANNEL_COLOR_TAG },
+
+  { "channels-color-tag-orange", NULL,
+    NC_("channels-action", "Orange"), NULL,
+    NC_("channels-action", "Set color tag to orange"),
+    GIMP_COLOR_TAG_ORANGE, FALSE,
+    GIMP_HELP_CHANNEL_COLOR_TAG },
+
+  { "channels-color-tag-brown", NULL,
+    NC_("channels-action", "Brown"), NULL,
+    NC_("channels-action", "Set color tag to brown"),
+    GIMP_COLOR_TAG_BROWN, FALSE,
+    GIMP_HELP_CHANNEL_COLOR_TAG },
+
+  { "channels-color-tag-red", NULL,
+    NC_("channels-action", "Red"), NULL,
+    NC_("channels-action", "Set color tag to red"),
+    GIMP_COLOR_TAG_RED, FALSE,
+    GIMP_HELP_CHANNEL_COLOR_TAG },
+
+  { "channels-color-tag-violet", NULL,
+    NC_("channels-action", "Violet"), NULL,
+    NC_("channels-action", "Set color tag to violet"),
+    GIMP_COLOR_TAG_VIOLET, FALSE,
+    GIMP_HELP_CHANNEL_COLOR_TAG },
+
+  { "channels-color-tag-gray", NULL,
+    NC_("channels-action", "Gray"), NULL,
+    NC_("channels-action", "Set color tag to gray"),
+    GIMP_COLOR_TAG_GRAY, FALSE,
+    GIMP_HELP_CHANNEL_COLOR_TAG }
+};
+
 static const GimpEnumActionEntry channels_to_selection_actions[] =
 {
   { "channels-selection-replace", GIMP_STOCK_SELECTION_REPLACE,
@@ -137,10 +226,21 @@ channels_actions_setup (GimpActionGroup *group)
                                  channels_actions,
                                  G_N_ELEMENTS (channels_actions));
 
+  gimp_action_group_add_toggle_actions (group, "channels-action",
+                                        channels_toggle_actions,
+                                        G_N_ELEMENTS (channels_toggle_actions));
+
+  gimp_action_group_add_enum_actions (group, "channels-action",
+                                      channels_color_tag_actions,
+                                      G_N_ELEMENTS (channels_color_tag_actions),
+                                      G_CALLBACK (channels_color_tag_cmd_callback));
+
   gimp_action_group_add_enum_actions (group, "channels-action",
                                       channels_to_selection_actions,
                                       G_N_ELEMENTS (channels_to_selection_actions),
                                       G_CALLBACK (channels_to_selection_cmd_callback));
+
+  items_actions_setup (group, "channels");
 }
 
 void
@@ -206,4 +306,6 @@ channels_actions_update (GimpActionGroup *group,
   SET_SENSITIVE ("channels-selection-intersect", !fs && (channel || component));
 
 #undef SET_SENSITIVE
+
+  items_actions_update (group, "channels", GIMP_ITEM (channel));
 }

app/actions/channels-commands.c

@@ -28,9 +28,13 @@
 
 #include "actions-types.h"
 
+#include "config/gimpdialogconfig.h"
+
+#include "core/gimp.h"
 #include "core/gimpchannel.h"
 #include "core/gimpchannel-select.h"
 #include "core/gimpcontext.h"
+#include "core/gimpdrawable-fill.h"
 #include "core/gimpimage.h"
 #include "core/gimpimage-undo.h"
 
@@ -40,28 +44,44 @@
 #include "widgets/gimpdock.h"
 #include "widgets/gimphelp-ids.h"
 
+#include "dialogs/dialogs.h"
 #include "dialogs/channel-options-dialog.h"
 
 #include "actions.h"
 #include "channels-commands.h"
+#include "items-commands.h"
 
 #include "gimp-intl.h"
 
 
 /*  local function prototypes  */
 
-static void   channels_new_channel_response  (GtkWidget            *widget,
+static void   channels_new_callback             (GtkWidget     *dialog,
-                                              gint                  response_id,
+                                                 GimpImage     *image,
-                                              ChannelOptionsDialog *options);
+                                                 GimpChannel   *channel,
-static void   channels_edit_channel_response (GtkWidget            *widget,
+                                                 GimpContext   *context,
-                                              gint                  response_id,
+                                                 const gchar   *channel_name,
-                                              ChannelOptionsDialog *options);
+                                                 const GimpRGB *channel_color,
-
+                                                 gboolean       save_selection,
-
+                                                 gboolean       channel_visible,
-/*  private variables  */
+                                                 gboolean       channel_linked,
-
+                                                 GimpColorTag   channel_color_tag,
-static gchar   *channel_name  = NULL;
+                                                 gboolean       channel_lock_content,
-static GimpRGB  channel_color = { 0.0, 0.0, 0.0, 0.5 };
+                                                 gboolean       channel_lock_position,
+                                                 gpointer       user_data);
+static void   channels_edit_attributes_callback (GtkWidget     *dialog,
+                                                 GimpImage     *image,
+                                                 GimpChannel   *channel,
+                                                 GimpContext   *context,
+                                                 const gchar   *channel_name,
+                                                 const GimpRGB *channel_color,
+                                                 gboolean       save_selection,
+                                                 gboolean       channel_visible,
+                                                 gboolean       channel_linked,
+                                                 GimpColorTag   channel_color_tag,
+                                                 gboolean       channel_lock_content,
+                                                 gboolean       channel_lock_position,
+                                                 gpointer       user_data);
 
 
 /*  public functions  */
@@ -70,76 +90,106 @@ void
 channels_edit_attributes_cmd_callback (GtkAction *action,
                                        gpointer   data)
 {
-  ChannelOptionsDialog *options;
+  GimpImage   *image;
-  GimpImage            *image;
+  GimpChannel *channel;
-  GimpChannel          *channel;
+  GtkWidget   *widget;
-  GtkWidget            *widget;
+  GtkWidget   *dialog;
   return_if_no_channel (image, channel, data);
   return_if_no_widget (widget, data);
 
-  options = channel_options_dialog_new (image, channel,
+#define EDIT_DIALOG_KEY "gimp-channel-edit-attributes-dialog"
-                                        action_data_get_context (data),
-                                        widget,
-                                        &channel->color,
-                                        gimp_object_get_name (channel),
-                                        _("Channel Attributes"),
-                                        "gimp-channel-edit",
-                                        "gtk-edit",
-                                        _("Edit Channel Attributes"),
-                                        GIMP_HELP_CHANNEL_EDIT,
-                                        _("Edit Channel Color"),
-                                        _("_Fill opacity:"),
-                                        FALSE);
 
-  g_signal_connect (options->dialog, "response",
+  dialog = dialogs_get_dialog (G_OBJECT (channel), EDIT_DIALOG_KEY);
-                    G_CALLBACK (channels_edit_channel_response),
-                    options);
 
-  gtk_widget_show (options->dialog);
+  if (! dialog)
+    {
+      GimpItem *item = GIMP_ITEM (channel);
+
+      dialog = channel_options_dialog_new (image, channel,
+                                           action_data_get_context (data),
+                                           widget,
+                                           _("Channel Attributes"),
+                                           "gimp-channel-edit",
+                                           "gtk-edit",
+                                           _("Edit Channel Attributes"),
+                                           GIMP_HELP_CHANNEL_EDIT,
+                                           _("Edit Channel Color"),
+                                           _("_Fill opacity:"),
+                                           FALSE,
+                                           gimp_object_get_name (channel),
+                                           &channel->color,
+                                           gimp_item_get_visible (item),
+                                           gimp_item_get_linked (item),
+                                           gimp_item_get_color_tag (item),
+                                           gimp_item_get_lock_content (item),
+                                           gimp_item_get_lock_position (item),
+                                           channels_edit_attributes_callback,
+                                           NULL);
+
+      dialogs_attach_dialog (G_OBJECT (channel), EDIT_DIALOG_KEY, dialog);
+    }
+
+  gtk_window_present (GTK_WINDOW (dialog));
 }
 
 void
 channels_new_cmd_callback (GtkAction *action,
                            gpointer   data)
 {
-  ChannelOptionsDialog *options;
+  GimpImage *image;
-  GimpImage            *image;
+  GtkWidget *widget;
-  GtkWidget            *widget;
+  GtkWidget *dialog;
   return_if_no_image (image, data);
   return_if_no_widget (widget, data);
 
-  options = channel_options_dialog_new (image, NULL,
+#define NEW_DIALOG_KEY "gimp-channel-new-dialog"
-                                        action_data_get_context (data),
-                                        widget,
-                                        &channel_color,
-                                        channel_name ? channel_name :
-                                        _("Channel"),
-                                        _("New Channel"),
-                                        "gimp-channel-new",
-                                        GIMP_STOCK_CHANNEL,
-                                        _("New Channel Options"),
-                                        GIMP_HELP_CHANNEL_NEW,
-                                        _("New Channel Color"),
-                                        _("_Fill opacity:"),
-                                        TRUE);
 
-  g_signal_connect (options->dialog, "response",
+  dialog = dialogs_get_dialog (G_OBJECT (image), NEW_DIALOG_KEY);
-                    G_CALLBACK (channels_new_channel_response),
-                    options);
 
-  gtk_widget_show (options->dialog);
+  if (! dialog)
+    {
+      GimpDialogConfig *config = GIMP_DIALOG_CONFIG (image->gimp->config);
+
+      dialog = channel_options_dialog_new (image, NULL,
+                                           action_data_get_context (data),
+                                           widget,
+                                           _("New Channel"),
+                                           "gimp-channel-new",
+                                           GIMP_STOCK_CHANNEL,
+                                           _("Create a New Channel"),
+                                           GIMP_HELP_CHANNEL_NEW,
+                                           _("New Channel Color"),
+                                           _("_Fill opacity:"),
+                                           TRUE,
+                                           config->channel_new_name,
+                                           &config->channel_new_color,
+                                           TRUE,
+                                           FALSE,
+                                           GIMP_COLOR_TAG_NONE,
+                                           FALSE,
+                                           FALSE,
+                                           channels_new_callback,
+                                           NULL);
+
+      dialogs_attach_dialog (G_OBJECT (image), NEW_DIALOG_KEY, dialog);
+    }
+
+  gtk_window_present (GTK_WINDOW (dialog));
 }
 
 void
 channels_new_last_vals_cmd_callback (GtkAction *action,
                                      gpointer   data)
 {
-  GimpImage   *image;
+  GimpImage        *image;
-  GimpChannel *new_channel;
+  GimpChannel      *new_channel;
-  gint         width, height;
+  gint              width, height;
-  GimpRGB      color;
+  GimpRGB           color;
+  GimpDialogConfig *config;
   return_if_no_image (image, data);
 
+  config = GIMP_DIALOG_CONFIG (image->gimp->config);
+
   if (GIMP_IS_CHANNEL (GIMP_ACTION (action)->viewable))
     {
       GimpChannel *template = GIMP_CHANNEL (GIMP_ACTION (action)->viewable);
@@ -152,14 +202,14 @@ channels_new_last_vals_cmd_callback (GtkAction *action,
     {
       width  = gimp_image_get_width (image);
       height = gimp_image_get_height (image);
-      color  = channel_color;
+      color  = config->channel_new_color;
     }
 
   gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_PASTE,
                                _("New Channel"));
 
   new_channel = gimp_channel_new (image, width, height,
-                                  channel_name, &color);
+                                  config->channel_new_name, &color);
 
   gimp_drawable_fill (GIMP_DRAWABLE (new_channel),
                       action_data_get_context (data),
@@ -270,7 +320,6 @@ channels_duplicate_cmd_callback (GtkAction *action,
     }
 
   gimp_image_add_channel (image, new_channel, parent, -1, TRUE);
-
   gimp_image_flush (image);
 }
 
@@ -318,101 +367,178 @@ channels_to_selection_cmd_callback (GtkAction *action,
   gimp_image_flush (image);
 }
 
+void
+channels_visible_cmd_callback (GtkAction *action,
+                               gpointer   data)
+{
+  GimpImage   *image;
+  GimpChannel *channel;
+  return_if_no_channel (image, channel, data);
+
+  items_visible_cmd_callback (action, image, GIMP_ITEM (channel));
+}
+
+void
+channels_linked_cmd_callback (GtkAction *action,
+                              gpointer   data)
+{
+  GimpImage   *image;
+  GimpChannel *channel;
+  return_if_no_channel (image, channel, data);
+
+  items_linked_cmd_callback (action, image, GIMP_ITEM (channel));
+}
+
+void
+channels_lock_content_cmd_callback (GtkAction *action,
+                                    gpointer   data)
+{
+  GimpImage   *image;
+  GimpChannel *channel;
+  return_if_no_channel (image, channel, data);
+
+  items_lock_content_cmd_callback (action, image, GIMP_ITEM (channel));
+}
+
+void
+channels_lock_position_cmd_callback (GtkAction *action,
+                                     gpointer   data)
+{
+  GimpImage   *image;
+  GimpChannel *channel;
+  return_if_no_channel (image, channel, data);
+
+  items_lock_position_cmd_callback (action, image, GIMP_ITEM (channel));
+}
+
+void
+channels_color_tag_cmd_callback (GtkAction *action,
+                                 gint       value,
+                                 gpointer   data)
+{
+  GimpImage   *image;
+  GimpChannel *channel;
+  return_if_no_channel (image, channel, data);
+
+  items_color_tag_cmd_callback (action, image, GIMP_ITEM (channel),
+                                (GimpColorTag) value);
+}
+
 
 /*  private functions  */
 
 static void
-channels_new_channel_response (GtkWidget            *widget,
+channels_new_callback (GtkWidget     *dialog,
-                               gint                  response_id,
+                       GimpImage     *image,
-                               ChannelOptionsDialog *options)
+                       GimpChannel   *channel,
+                       GimpContext   *context,
+                       const gchar   *channel_name,
+                       const GimpRGB *channel_color,
+                       gboolean       save_selection,
+                       gboolean       channel_visible,
+                       gboolean       channel_linked,
+                       GimpColorTag   channel_color_tag,
+                       gboolean       channel_lock_content,
+                       gboolean       channel_lock_position,
+                       gpointer       user_data)
 {
-  if (response_id == GTK_RESPONSE_OK)
+  GimpDialogConfig *config = GIMP_DIALOG_CONFIG (image->gimp->config);
+
+  g_object_set (config,
+                "channel-new-name",  channel_name,
+                "channel-new-color", channel_color,
+                NULL);
+
+  if (save_selection)
     {
-      GimpChannel *new_channel;
+      GimpChannel *selection = gimp_image_get_mask (image);
 
-      if (channel_name)
+      channel = GIMP_CHANNEL (gimp_item_duplicate (GIMP_ITEM (selection),
-        g_free (channel_name);
+                                                   GIMP_TYPE_CHANNEL));
 
-      channel_name =
+      gimp_object_set_name (GIMP_OBJECT (channel),
-        g_strdup (gtk_entry_get_text (GTK_ENTRY (options->name_entry)));
+                            config->channel_new_name);
+      gimp_channel_set_color (channel, &config->channel_new_color, FALSE);
+    }
+  else
+    {
+      channel = gimp_channel_new (image,
+                                  gimp_image_get_width  (image),
+                                  gimp_image_get_height (image),
+                                  config->channel_new_name,
+                                  &config->channel_new_color);
 
-      gimp_color_button_get_color (GIMP_COLOR_BUTTON (options->color_panel),
+      gimp_drawable_fill (GIMP_DRAWABLE (channel), context,
-                                   &channel_color);
+                          GIMP_FILL_TRANSPARENT);
-
-      if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (options->save_sel_checkbutton)))
-        {
-          GimpChannel *selection = gimp_image_get_mask (options->image);
-
-          new_channel =
-            GIMP_CHANNEL (gimp_item_duplicate (GIMP_ITEM (selection),
-                                               GIMP_TYPE_CHANNEL));
-
-          gimp_object_set_name (GIMP_OBJECT (new_channel), channel_name);
-          gimp_channel_set_color (new_channel, &channel_color, FALSE);
-        }
-      else
-        {
-          new_channel = gimp_channel_new (options->image,
-                                          gimp_image_get_width  (options->image),
-                                          gimp_image_get_height (options->image),
-                                          channel_name,
-                                          &channel_color);
-
-          gimp_drawable_fill (GIMP_DRAWABLE (new_channel),
-                              options->context,
-                              GIMP_FILL_TRANSPARENT);
-        }
-
-      gimp_image_add_channel (options->image, new_channel,
-                              GIMP_IMAGE_ACTIVE_PARENT, -1, TRUE);
-
-      gimp_image_flush (options->image);
     }
 
-  gtk_widget_destroy (options->dialog);
+  gimp_item_set_visible (GIMP_ITEM (channel), channel_visible, FALSE);
+  gimp_item_set_linked (GIMP_ITEM (channel), channel_linked, FALSE);
+  gimp_item_set_color_tag (GIMP_ITEM (channel), channel_color_tag, FALSE);
+  gimp_item_set_lock_content (GIMP_ITEM (channel), channel_lock_content, FALSE);
+  gimp_item_set_lock_position (GIMP_ITEM (channel), channel_lock_position, FALSE);
+
+  gimp_image_add_channel (image, channel,
+                          GIMP_IMAGE_ACTIVE_PARENT, -1, TRUE);
+  gimp_image_flush (image);
+
+  gtk_widget_destroy (dialog);
 }
 
 static void
-channels_edit_channel_response (GtkWidget            *widget,
+channels_edit_attributes_callback (GtkWidget     *dialog,
-                                gint                  response_id,
+                                   GimpImage     *image,
-                                ChannelOptionsDialog *options)
+                                   GimpChannel   *channel,
+                                   GimpContext   *context,
+                                   const gchar   *channel_name,
+                                   const GimpRGB *channel_color,
+                                   gboolean       save_selection,
+                                   gboolean       channel_visible,
+                                   gboolean       channel_linked,
+                                   GimpColorTag   channel_color_tag,
+                                   gboolean       channel_lock_content,
+                                   gboolean       channel_lock_position,
+                                   gpointer       user_data)
 {
-  if (response_id == GTK_RESPONSE_OK)
+  GimpItem *item = GIMP_ITEM (channel);
+
+  if (strcmp (channel_name, gimp_object_get_name (channel))        ||
+      gimp_rgba_distance (channel_color, &channel->color) > 0.0001 ||
+      channel_visible       != gimp_item_get_visible (item)        ||
+      channel_linked        != gimp_item_get_linked (item)         ||
+      channel_color_tag     != gimp_item_get_color_tag (item)      ||
+      channel_lock_content  != gimp_item_get_lock_content (item)   ||
+      channel_lock_position != gimp_item_get_lock_position (item))
     {
-      GimpChannel *channel = options->channel;
+      gimp_image_undo_group_start (image,
-      const gchar *new_name;
+                                   GIMP_UNDO_GROUP_ITEM_PROPERTIES,
-      GimpRGB      color;
+                                   _("Channel Attributes"));
-      gboolean     name_changed  = FALSE;
-      gboolean     color_changed = FALSE;
 
-      new_name = gtk_entry_get_text (GTK_ENTRY (options->name_entry));
+      if (strcmp (channel_name, gimp_object_get_name (channel)))
+        gimp_item_rename (GIMP_ITEM (channel), channel_name, NULL);
 
-      gimp_color_button_get_color (GIMP_COLOR_BUTTON (options->color_panel),
+      if (gimp_rgba_distance (channel_color, &channel->color) > 0.0001)
-                                   &color);
+        gimp_channel_set_color (channel, channel_color, TRUE);
 
-      if (strcmp (new_name, gimp_object_get_name (channel)))
+      if (channel_visible != gimp_item_get_visible (item))
-        name_changed = TRUE;
+        gimp_item_set_visible (item, channel_visible, TRUE);
 
-      if (gimp_rgba_distance (&color, &channel->color) > 0.0001)
+      if (channel_linked != gimp_item_get_linked (item))
-        color_changed = TRUE;
+        gimp_item_set_linked (item, channel_linked, TRUE);
 
-      if (name_changed && color_changed)
+      if (channel_color_tag != gimp_item_get_color_tag (item))
-        gimp_image_undo_group_start (options->image,
+        gimp_item_set_color_tag (item, channel_color_tag, TRUE);
-                                     GIMP_UNDO_GROUP_ITEM_PROPERTIES,
-                                     _("Channel Attributes"));
 
-      if (name_changed)
+      if (channel_lock_content != gimp_item_get_lock_content (item))
-        gimp_item_rename (GIMP_ITEM (channel), new_name, NULL);
+        gimp_item_set_lock_content (item, channel_lock_content, TRUE);
 
-      if (color_changed)
+      if (channel_lock_position != gimp_item_get_lock_position (item))
-        gimp_channel_set_color (channel, &color, TRUE);
+        gimp_item_set_lock_position (item, channel_lock_position, TRUE);
 
-      if (name_changed && color_changed)
+      gimp_image_undo_group_end (image);
-        gimp_image_undo_group_end (options->image);
 
-      if (name_changed || color_changed)
+      gimp_image_flush (image);
-        gimp_image_flush (options->image);
     }
 
-  gtk_widget_destroy (options->dialog);
+  gtk_widget_destroy (dialog);
 }

app/actions/channels-commands.h

@@ -43,5 +43,18 @@ void   channels_to_selection_cmd_callback    (GtkAction   *action,
                                               gint         value,
                                               gpointer     data);
 
+void   channels_visible_cmd_callback         (GtkAction   *action,
+                                              gpointer     data);
+void   channels_linked_cmd_callback          (GtkAction   *action,
+                                              gpointer     data);
+void   channels_lock_content_cmd_callback    (GtkAction   *action,
+                                              gpointer     data);
+void   channels_lock_position_cmd_callback   (GtkAction   *action,
+                                              gpointer     data);
+
+void   channels_color_tag_cmd_callback       (GtkAction   *action,
+                                              gint         value,
+                                              gpointer     data);
+
 
 #endif /* __CHANNELS_COMMANDS_H__ */

app/actions/context-actions.c

@@ -61,7 +61,7 @@ static const GimpActionEntry context_actions[] =
                                                               "_Palette")    },
   { "context-gradient-menu",   GIMP_STOCK_GRADIENT,       NC_("context-action",
                                                               "_Gradient")   },
-  { "context-font-menu",       GIMP_STOCK_FONT,           NC_("context-action",
+  { "context-font-menu",       "gtk-select-font",         NC_("context-action",
                                                               "_Font")       },
 
   { "context-brush-shape-menu",    NULL,                  NC_("context-action",
@@ -841,23 +841,23 @@ static const GimpEnumActionEntry context_gradient_select_actions[] =
 
 static const GimpEnumActionEntry context_font_select_actions[] =
 {
-  { "context-font-select-set", GIMP_STOCK_FONT,
+  { "context-font-select-set", "gtk-select-font",
     "Select Font by Index", NULL, NULL,
     GIMP_ACTION_SELECT_SET, TRUE,
     NULL },
-  { "context-font-select-first", GIMP_STOCK_FONT,
+  { "context-font-select-first", "gtk-select-font",
     "First Font", NULL, NULL,
     GIMP_ACTION_SELECT_FIRST, FALSE,
     NULL },
-  { "context-font-select-last", GIMP_STOCK_FONT,
+  { "context-font-select-last", "gtk-select-font",
     "Last Font", NULL, NULL,
     GIMP_ACTION_SELECT_LAST, FALSE,
     NULL },
-  { "context-font-select-previous", GIMP_STOCK_FONT,
+  { "context-font-select-previous", "gtk-select-font",
     "Previous Font", NULL, NULL,
     GIMP_ACTION_SELECT_PREVIOUS, FALSE,
     NULL },
-  { "context-font-select-next", GIMP_STOCK_FONT,
+  { "context-font-select-next", "gtk-select-font",
     "Next Font", NULL, NULL,
     GIMP_ACTION_SELECT_NEXT, FALSE,
     NULL }
@@ -1243,6 +1243,7 @@ void
 context_actions_update (GimpActionGroup *group,
                         gpointer         data)
 {
+#if 0
   GimpContext *context   = action_data_get_context (data);
   gboolean     generated = FALSE;
   gdouble      radius    = 0.0;
@@ -1272,7 +1273,6 @@ context_actions_update (GimpActionGroup *group,
 #define SET_SENSITIVE(action,condition) \
         gimp_action_group_set_action_sensitive (group, "context-" action, (condition) != 0)
 
-#if 0
   SET_SENSITIVE ("brush-radius-minimum",       generated && radius > 1.0);
   SET_SENSITIVE ("brush-radius-decrease",      generated && radius > 1.0);
   SET_SENSITIVE ("brush-radius-decrease-skip", generated && radius > 1.0);
@@ -1288,7 +1288,7 @@ context_actions_update (GimpActionGroup *group,
   SET_SENSITIVE ("brush-angle-maximum",       generated);
   SET_SENSITIVE ("brush-angle-increase",      generated);
   SET_SENSITIVE ("brush-angle-increase-skip", generated);
-#endif
-
 #undef SET_SENSITIVE
+
+#endif
 }

app/actions/cursor-info-commands.c

@@ -17,23 +17,14 @@
 
 #include "config.h"
 
-#include <gegl.h>
 #include <gtk/gtk.h>
 
-#include "libgimpbase/gimpbase.h"
-#include "libgimpwidgets/gimpwidgets.h"
-
 #include "actions-types.h"
 
-#include "widgets/gimphelp-ids.h"
-#include "widgets/gimpwidgets-utils.h"
-
 #include "display/gimpcursorview.h"
 
 #include "cursor-info-commands.h"
 
-#include "gimp-intl.h"
-
 
 /*  public functions  */
 

app/actions/data-commands.c

@@ -71,7 +71,7 @@ data_open_as_image_cmd_callback (GtkAction *action,
 
   if (data && gimp_data_get_file (data))
     {
-      GFile             *file = gimp_data_get_file (data);
+      GFile             *file   = gimp_data_get_file (data);
       GtkWidget         *widget = GTK_WIDGET (view);
       GimpImage         *image;
       GimpPDBStatusType  status;
@@ -138,8 +138,7 @@ data_duplicate_cmd_callback (GtkAction *action,
     gimp_context_get_by_type (context,
                               gimp_data_factory_view_get_children_type (view));
 
-  if (data && gimp_data_factory_view_have (view,
+  if (data && gimp_data_factory_view_have (view, GIMP_OBJECT (data)))
-                                           GIMP_OBJECT (data)))
     {
       GimpData *new_data;
 
@@ -235,8 +234,7 @@ data_delete_cmd_callback (GtkAction *action,
 
   if (data                          &&
       gimp_data_is_deletable (data) &&
-      gimp_data_factory_view_have (view,
+      gimp_data_factory_view_have (view, GIMP_OBJECT (data)))
-                                   GIMP_OBJECT (data)))
     {
       GimpDataFactory *factory;
       GtkWidget       *dialog;
@@ -278,8 +276,7 @@ data_edit_cmd_callback (GtkAction   *action,
     gimp_context_get_by_type (context,
                               gimp_data_factory_view_get_children_type (view));
 
-  if (data && gimp_data_factory_view_have (view,
+  if (data && gimp_data_factory_view_have (view, GIMP_OBJECT (data)))
-                                           GIMP_OBJECT (data)))
     {
       GdkScreen *screen  = gtk_widget_get_screen (GTK_WIDGET (view));
       gint       monitor = gimp_widget_get_monitor (GTK_WIDGET (view));

app/actions/dialogs-actions.c

@@ -61,6 +61,12 @@ const GimpStringActionEntry dialogs_dockable_actions[] =
     "gimp-device-status",
     GIMP_HELP_DEVICE_STATUS_DIALOG },
 
+  { "dialogs-symmetry", GIMP_STOCK_SYMMETRY,
+    NC_("dialogs-action", "_Symmetry Painting"), NULL,
+    NC_("dialogs-action", "Open the symmetry dialog"),
+    "gimp-symmetry-editor",
+    GIMP_HELP_SYMMETRY_DIALOG },
+
   { "dialogs-layers", GIMP_STOCK_LAYERS,
     NC_("dialogs-action", "_Layers"), "<primary>L",
     NC_("dialogs-action", "Open the layers dialog"),
@@ -91,7 +97,7 @@ const GimpStringActionEntry dialogs_dockable_actions[] =
     "gimp-histogram-editor",
     GIMP_HELP_HISTOGRAM_DIALOG },
 
-  { "dialogs-selection-editor", GIMP_STOCK_TOOL_RECT_SELECT,
+  { "dialogs-selection-editor", GIMP_STOCK_SELECTION,
     NC_("dialogs-action", "_Selection Editor"), NULL,
     NC_("dialogs-action", "Open the selection editor"),
     "gimp-selection-editor",
@@ -142,7 +148,7 @@ const GimpStringActionEntry dialogs_dockable_actions[] =
   { "dialogs-dynamics", GIMP_STOCK_DYNAMICS,
     NC_("dialogs-action", "Paint Dynamics"), NULL,
     NC_("dialogs-action", "Open paint dynamics dialog"),
-    "gimp-dynamics-list",
+    "gimp-dynamics-list|gimp-dynamics-grid",
     GIMP_HELP_DYNAMICS_DIALOG },
 
   { "dialogs-dynamics-editor", GIMP_STOCK_DYNAMICS,
@@ -151,6 +157,12 @@ const GimpStringActionEntry dialogs_dockable_actions[] =
     "gimp-dynamics-editor",
     GIMP_HELP_DYNAMICS_EDITOR_DIALOG },
 
+  { "dialogs-mypaint-brushes", GIMP_STOCK_MYPAINT_BRUSH,
+    NC_("dialogs-action", "_MyPaint Brushes"), "<primary><shift>Y",
+    NC_("dialogs-action", "Open the mypaint brushes dialog"),
+    "gimp-mypaint-brush-grid|gimp-mapyint-brush-list",
+    GIMP_HELP_MYPAINT_BRUSH_DIALOG },
+
   { "dialogs-patterns", GIMP_STOCK_PATTERN,
     NC_("dialogs-action", "P_atterns"), "<primary><shift>P",
     NC_("dialogs-action", "Open the patterns dialog"),
@@ -184,10 +196,10 @@ const GimpStringActionEntry dialogs_dockable_actions[] =
   { "dialogs-tool-presets", GIMP_STOCK_TOOL_PRESET,
     NC_("dialogs-action", "Tool presets"), NULL,
     NC_("dialogs-action", "Open tool presets dialog"),
-    "gimp-tool-preset-list",
+    "gimp-tool-preset-list|gimp-tool-preset-grid",
     GIMP_HELP_TOOL_PRESET_DIALOG },
 
-  { "dialogs-fonts", GIMP_STOCK_FONT,
+  { "dialogs-fonts", "gtk-select-font",
     NC_("dialogs-action", "_Fonts"), NULL,
     NC_("dialogs-action", "Open the fonts dialog"),
     "gimp-font-list|gimp-font-grid",
@@ -271,9 +283,9 @@ static const GimpStringActionEntry dialogs_toplevel_actions[] =
     "gimp-about-dialog",
       GIMP_HELP_ABOUT_DIALOG },
 
-  { "help-action-search", "edit-find",
+  { "dialogs-action-search", "edit-find",
-    NC_("help-action", "_Search and Run a Command"), "slash",
+    NC_("dialogs-action", "_Search and Run a Command"), "slash",
-    NC_("help-action", "Search commands by keyword, and run them"),
+    NC_("dialogs-action", "Search commands by keyword, and run them"),
     "gimp-action-search-dialog",
     GIMP_HELP_ACTION_SEARCH_DIALOG }
 };

app/actions/dock-commands.c

@@ -59,6 +59,7 @@ dock_toggle_image_menu_cmd_callback (GtkAction *action,
   if (dock_window)
     {
       gboolean active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+
       gimp_dock_window_set_show_image_menu (dock_window, active);
     }
 }
@@ -76,6 +77,7 @@ dock_toggle_auto_cmd_callback (GtkAction *action,
   if (dock_window)
     {
       gboolean active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+
       gimp_dock_window_set_auto_follow_active (dock_window, active);
     }
 }

app/actions/dockable-actions.c

@@ -49,7 +49,7 @@ static const GimpActionEntry dockable_actions[] =
     NC_("dockable-action", "Dialogs Menu"), NULL, NULL, NULL,
     GIMP_HELP_DOCK },
 
-  { "dockable-menu",              "image-mising", ""           },
+  { "dockable-menu",              "image-missing", ""           },
   { "dockable-add-tab-menu",      NULL, NC_("dockable-action",
                                             "_Add Tab")        },
   { "dockable-preview-size-menu", NULL, NC_("dockable-action",

app/actions/dockable-commands.c

@@ -283,6 +283,9 @@ dockable_show_button_bar_cmd_callback (GtkAction *action,
     }
 }
 
+
+/*  private functions  */
+
 static GimpDockable *
 dockable_get_current (GimpDockbook *dockbook)
 {

app/actions/documents-actions.c

@@ -66,7 +66,7 @@ static const GimpActionEntry documents_actions[] =
     G_CALLBACK (documents_copy_location_cmd_callback),
     GIMP_HELP_DOCUMENT_COPY_LOCATION },
 
-  { "documents-show-in-file-manager", "gtk-directory",
+  { "documents-show-in-file-manager", GIMP_STOCK_FILE_MANAGER,
     NC_("documents-action", "Show in _File Manager"), NULL,
     NC_("documents-action", "Show image location in the file manager"),
     G_CALLBACK (documents_show_in_file_manager_cmd_callback),
@@ -78,7 +78,7 @@ static const GimpActionEntry documents_actions[] =
     G_CALLBACK (documents_remove_cmd_callback),
     GIMP_HELP_DOCUMENT_REMOVE },
 
-  { "documents-clear", "edit-clear",
+  { "documents-clear", GIMP_STOCK_SHRED,
     NC_("documents-action", "_Clear History"), NULL,
     NC_("documents-action", "Clear the entire document history"),
     G_CALLBACK (documents_clear_cmd_callback),

app/actions/documents-commands.c

@@ -221,7 +221,7 @@ documents_clear_cmd_callback (GtkAction *action,
   GtkWidget           *dialog;
 
   dialog = gimp_message_dialog_new (_("Clear Document History"),
-                                    "edit-clear",
+                                    GIMP_STOCK_SHRED,
                                     GTK_WIDGET (editor),
                                     GTK_DIALOG_MODAL |
                                     GTK_DIALOG_DESTROY_WITH_PARENT,

app/actions/drawable-commands.c

@@ -27,6 +27,7 @@
 #include "core/gimp.h"
 #include "core/gimpdrawable-equalize.h"
 #include "core/gimpdrawable-levels.h"
+#include "core/gimpdrawable-offset.h"
 #include "core/gimpdrawable-operation.h"
 #include "core/gimpimage.h"
 #include "core/gimpimage-undo.h"
@@ -35,6 +36,7 @@
 #include "core/gimplayermask.h"
 #include "core/gimpprogress.h"
 
+#include "dialogs/dialogs.h"
 #include "dialogs/offset-dialog.h"
 
 #include "actions.h"
@@ -43,6 +45,17 @@
 #include "gimp-intl.h"
 
 
+/*  local function prototypes  */
+
+static void   drawable_offset_callback (GtkWidget      *dialog,
+                                        GimpDrawable   *drawable,
+                                        GimpContext    *context,
+                                        gboolean        wrap_around,
+                                        GimpOffsetType  fill_type,
+                                        gint            offset_x,
+                                        gint            offset_y);
+
+
 /*  public functions  */
 
 void
@@ -106,7 +119,8 @@ drawable_levels_stretch_cmd_callback (GtkAction *action,
     {
       gimp_message_literal (image->gimp,
                             G_OBJECT (widget), GIMP_MESSAGE_WARNING,
-                            _("White Balance operates only on RGB color layers."));
+                            _("White Balance operates only on RGB color "
+                              "layers."));
       return;
     }
 
@@ -189,11 +203,23 @@ drawable_offset_cmd_callback (GtkAction *action,
   return_if_no_drawable (image, drawable, data);
   return_if_no_widget (widget, data);
 
-  dialog = offset_dialog_new (drawable, action_data_get_context (data),
+#define OFFSET_DIALOG_KEY "gimp-offset-dialog"
-                              widget);
-  gtk_widget_show (dialog);
-}
 
+  dialog = dialogs_get_dialog (G_OBJECT (drawable), OFFSET_DIALOG_KEY);
+
+  if (! dialog)
+    {
+      dialog = offset_dialog_new (drawable, action_data_get_context (data),
+                                  widget,
+                                  drawable_offset_callback,
+                                  NULL);
+
+      dialogs_attach_dialog (G_OBJECT (drawable),
+                             OFFSET_DIALOG_KEY, dialog);
+    }
+
+  gtk_window_present (GTK_WINDOW (dialog));
+}
 
 void
 drawable_linked_cmd_callback (GtkAction *action,
@@ -407,3 +433,25 @@ drawable_rotate_cmd_callback (GtkAction *action,
 
   gimp_image_flush (image);
 }
+
+
+/*  private functions  */
+
+static void
+drawable_offset_callback (GtkWidget      *dialog,
+                          GimpDrawable   *drawable,
+                          GimpContext    *context,
+                          gboolean        wrap_around,
+                          GimpOffsetType  fill_type,
+                          gint            offset_x,
+                          gint            offset_y)
+{
+  GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
+
+  gimp_drawable_offset (drawable, context,
+                        wrap_around, fill_type,
+                        offset_x, offset_y);
+  gimp_image_flush (image);
+
+  gtk_widget_destroy (dialog);
+}

app/actions/dynamics-actions.c

@@ -61,7 +61,7 @@ static const GimpActionEntry dynamics_actions[] =
     G_CALLBACK (data_copy_location_cmd_callback),
     GIMP_HELP_DYNAMICS_COPY_LOCATION },
 
-  { "dynamics-show-in-file-manager", "gtk-directory",
+  { "dynamics-show-in-file-manager", GIMP_STOCK_FILE_MANAGER,
     NC_("dynamics-action", "Show in _File Manager"), NULL,
     NC_("dynamics-action", "Show dynamics file location in the file manager"),
     G_CALLBACK (data_show_in_file_manager_cmd_callback),
@@ -84,7 +84,7 @@ static const GimpStringActionEntry dynamics_edit_actions[] =
 {
   { "dynamics-edit", "gtk-edit",
     NC_("dynamics-action", "_Edit Dynamics..."), NULL,
-    NC_("dynamics-action", "Edit dynamics"),
+    NC_("dynamics-action", "Edit this dynamics"),
     "gimp-dynamics-editor",
     GIMP_HELP_DYNAMICS_EDIT }
 };

app/actions/edit-actions.c

@@ -95,7 +95,7 @@ static const GimpActionEntry edit_actions[] =
     G_CALLBACK (edit_strong_redo_cmd_callback),
     GIMP_HELP_EDIT_STRONG_REDO },
 
-  { "edit-undo-clear", "edit-clear",
+  { "edit-undo-clear", GIMP_STOCK_SHRED,
     NC_("edit-action", "_Clear Undo History"), NULL,
     NC_("edit-action", "Remove all operations from the undo history"),
     G_CALLBACK (edit_undo_clear_cmd_callback),
@@ -139,24 +139,24 @@ static const GimpActionEntry edit_actions[] =
     G_CALLBACK (edit_paste_into_cmd_callback),
     GIMP_HELP_EDIT_PASTE_INTO },
 
-  { "edit-paste-as-new", GIMP_STOCK_PASTE_AS_NEW,
-    NC_("edit-action", "From _Clipboard"), "<primary><shift>V",
-    NC_("edit-action", "Create a new image from the content of the clipboard"),
-    G_CALLBACK (edit_paste_as_new_cmd_callback),
-    GIMP_HELP_EDIT_PASTE_AS_NEW },
-
-  { "edit-paste-as-new-short", GIMP_STOCK_PASTE_AS_NEW,
-    NC_("edit-action", "_New Image"), NULL,
-    NC_("edit-action", "Create a new image from the content of the clipboard"),
-    G_CALLBACK (edit_paste_as_new_cmd_callback),
-    GIMP_HELP_EDIT_PASTE_AS_NEW },
-
   { "edit-paste-as-new-layer", NULL,
     NC_("edit-action", "New _Layer"), NULL,
     NC_("edit-action", "Create a new layer from the content of the clipboard"),
     G_CALLBACK (edit_paste_as_new_layer_cmd_callback),
     GIMP_HELP_EDIT_PASTE_AS_NEW_LAYER },
 
+  { "edit-paste-as-new-image", GIMP_STOCK_PASTE_AS_NEW,
+    NC_("edit-action", "From _Clipboard"), "<primary><shift>V",
+    NC_("edit-action", "Create a new image from the content of the clipboard"),
+    G_CALLBACK (edit_paste_as_new_image_cmd_callback),
+    GIMP_HELP_EDIT_PASTE_AS_NEW_IMAGE },
+
+  { "edit-paste-as-new-image-short", GIMP_STOCK_PASTE_AS_NEW,
+    NC_("edit-action", "_New Image"), NULL,
+    NC_("edit-action", "Create a new image from the content of the clipboard"),
+    G_CALLBACK (edit_paste_as_new_image_cmd_callback),
+    GIMP_HELP_EDIT_PASTE_AS_NEW_IMAGE },
+
   { "edit-named-cut", "edit-cut",
     NC_("edit-action", "Cu_t Named..."), NULL,
     NC_("edit-action", "Move the selected pixels to a named buffer"),
@@ -203,7 +203,7 @@ static const GimpEnumActionEntry edit_fill_actions[] =
     GIMP_FILL_BACKGROUND, FALSE,
     GIMP_HELP_EDIT_FILL_BG },
 
-  { "edit-fill-pattern", GIMP_STOCK_TOOL_BUCKET_FILL,
+  { "edit-fill-pattern", GIMP_STOCK_PATTERN,
     NC_("edit-action", "Fill _with Pattern"), "<primary>semicolon",
     NC_("edit-action", "Fill the selection using the active pattern"),
     GIMP_FILL_PATTERN, FALSE,
@@ -229,12 +229,12 @@ edit_actions_setup (GimpActionGroup *group)
                                       G_CALLBACK (edit_fill_cmd_callback));
 
   action = gtk_action_group_get_action (GTK_ACTION_GROUP (group),
-                                        "edit-paste-as-new-short");
+                                        "edit-paste-as-new-image-short");
-  gtk_action_set_accel_path (action, "<Actions>/edit/edit-paste-as-new");
+  gtk_action_set_accel_path (action, "<Actions>/edit/edit-paste-as-new-image");
 
-  action = gtk_action_group_get_action (GTK_ACTION_GROUP (group),
+  gimp_action_group_set_action_context (group, "edit-fill-fg", context);
-                                        "edit-fill-pattern");
+  gimp_action_group_set_action_context (group, "edit-fill-bg", context);
-  g_object_set (action, "context", context, NULL);
+  gimp_action_group_set_action_context (group, "edit-fill-pattern", context);
 
   g_signal_connect_object (context, "foreground-changed",
                            G_CALLBACK (edit_actions_foreground_changed),
@@ -364,16 +364,14 @@ edit_actions_update (GimpActionGroup *group,
   SET_SENSITIVE ("edit-cut",                writable && !children);
   SET_SENSITIVE ("edit-copy",               drawable);
   SET_SENSITIVE ("edit-copy-visible",       image);
-  SET_SENSITIVE ("edit-paste",              !image || (!drawable ||
+  /*             "edit-paste" is always active */
-                                                       (writable && !children)));
+  SET_SENSITIVE ("edit-paste-into",         image);
   SET_SENSITIVE ("edit-paste-as-new-layer", image);
-  SET_SENSITIVE ("edit-paste-into",         image && (!drawable ||
-                                                      (writable  && !children)));
 
   SET_SENSITIVE ("edit-named-cut",          writable && !children);
   SET_SENSITIVE ("edit-named-copy",         drawable);
   SET_SENSITIVE ("edit-named-copy-visible", drawable);
-  SET_SENSITIVE ("edit-named-paste",        TRUE);
+  /*             "edit-named-paste" is always active */
 
   SET_SENSITIVE ("edit-clear",              writable && !children);
   SET_SENSITIVE ("edit-fill-fg",            writable && !children);

app/actions/edit-commands.c

@@ -32,9 +32,11 @@
 #include "core/gimpbuffer.h"
 #include "core/gimpcontainer.h"
 #include "core/gimpdrawable.h"
+#include "core/gimpfilloptions.h"
 #include "core/gimplayer.h"
 #include "core/gimplayer-new.h"
 #include "core/gimpimage.h"
+#include "core/gimpimage-duplicate.h"
 #include "core/gimpimage-new.h"
 #include "core/gimpimage-undo.h"
 
@@ -64,17 +66,18 @@
 
 /*  local function prototypes  */
 
-static void   edit_paste                         (GimpDisplay *display,
+static void   edit_paste                         (GimpDisplay   *display,
-                                                  gboolean     paste_into);
+                                                  GimpPasteType  paste_into,
-static void   cut_named_buffer_callback          (GtkWidget   *widget,
+                                                  gboolean       try_svg);
-                                                  const gchar *name,
+static void   cut_named_buffer_callback          (GtkWidget     *widget,
-                                                  gpointer     data);
+                                                  const gchar   *name,
-static void   copy_named_buffer_callback         (GtkWidget   *widget,
+                                                  gpointer       data);
-                                                  const gchar *name,
+static void   copy_named_buffer_callback         (GtkWidget     *widget,
-                                                  gpointer     data);
+                                                  const gchar   *name,
-static void   copy_named_visible_buffer_callback (GtkWidget   *widget,
+                                                  gpointer       data);
-                                                  const gchar *name,
+static void   copy_named_visible_buffer_callback (GtkWidget     *widget,
-                                                  gpointer     data);
+                                                  const gchar   *name,
+                                                  gpointer       data);
 
 
 /*  public functions  */
@@ -201,23 +204,50 @@ edit_undo_clear_cmd_callback (GtkAction *action,
   gtk_widget_destroy (dialog);
 }
 
+void
+edit_fade_cmd_callback (GtkAction *action,
+                        gpointer   data)
+{
+  GimpImage *image;
+  GtkWidget *widget;
+  GtkWidget *dialog;
+  return_if_no_image (image, data);
+  return_if_no_widget (widget, data);
+
+  dialog = fade_dialog_new (image, widget);
+
+  if (dialog)
+    {
+      g_signal_connect_object (image, "disconnect",
+                               G_CALLBACK (gtk_widget_destroy),
+                               dialog, G_CONNECT_SWAPPED);
+      gtk_widget_show (dialog);
+    }
+}
+
 void
 edit_cut_cmd_callback (GtkAction *action,
                        gpointer   data)
 {
   GimpImage    *image;
   GimpDrawable *drawable;
+  GimpObject   *cut;
   GError       *error = NULL;
   return_if_no_drawable (image, drawable, data);
 
-  if (gimp_edit_cut (image, drawable, action_data_get_context (data), &error))
+  cut = gimp_edit_cut (image, drawable, action_data_get_context (data),
+                       &error);
+
+  if (cut)
     {
       GimpDisplay *display = action_data_get_display (data);
 
       if (display)
         gimp_message_literal (image->gimp,
                               G_OBJECT (display), GIMP_MESSAGE_INFO,
-                              _("Cut pixels to the clipboard"));
+                              GIMP_IS_IMAGE (cut) ?
+                              _("Cut layer to the clipboard.") :
+                              _("Cut pixels to the clipboard."));
 
       gimp_image_flush (image);
     }
@@ -237,17 +267,23 @@ edit_copy_cmd_callback (GtkAction *action,
 {
   GimpImage    *image;
   GimpDrawable *drawable;
+  GimpObject   *copy;
   GError       *error = NULL;
   return_if_no_drawable (image, drawable, data);
 
-  if (gimp_edit_copy (image, drawable, action_data_get_context (data), &error))
+  copy = gimp_edit_copy (image, drawable, action_data_get_context (data),
+                         &error);
+
+  if (copy)
     {
       GimpDisplay *display = action_data_get_display (data);
 
       if (display)
         gimp_message_literal (image->gimp,
                               G_OBJECT (display), GIMP_MESSAGE_INFO,
-                              _("Copied pixels to the clipboard"));
+                              GIMP_IS_IMAGE (copy) ?
+                              _("Copied layer to the clipboard.") :
+                              _("Copied pixels to the clipboard."));
 
       gimp_image_flush (image);
     }
@@ -276,7 +312,7 @@ edit_copy_visible_cmd_callback (GtkAction *action,
       if (display)
         gimp_message_literal (image->gimp,
                               G_OBJECT (display), GIMP_MESSAGE_INFO,
-                              _("Copied pixels to the clipboard"));
+                              _("Copied pixels to the clipboard."));
 
       gimp_image_flush (image);
     }
@@ -297,9 +333,13 @@ edit_paste_cmd_callback (GtkAction *action,
   GimpDisplay *display = action_data_get_display (data);
 
   if (display && gimp_display_get_image (display))
-    edit_paste (display, FALSE);
+    {
+      edit_paste (display, GIMP_PASTE_TYPE_FLOATING, TRUE);
+    }
   else
-    edit_paste_as_new_cmd_callback (action, data);
+    {
+      edit_paste_as_new_image_cmd_callback (action, data);
+    }
 }
 
 void
@@ -309,30 +349,51 @@ edit_paste_into_cmd_callback (GtkAction *action,
   GimpDisplay *display;
   return_if_no_display (display, data);
 
-  edit_paste (display, TRUE);
+  edit_paste (display, GIMP_PASTE_TYPE_FLOATING_INTO, TRUE);
 }
 
 void
-edit_paste_as_new_cmd_callback (GtkAction *action,
+edit_paste_as_new_layer_cmd_callback (GtkAction *action,
-                                gpointer   data)
+                                      gpointer   data)
+{
+  GimpDisplay *display;
+  return_if_no_display (display, data);
+
+  edit_paste (display, GIMP_PASTE_TYPE_NEW_LAYER, FALSE);
+}
+
+void
+edit_paste_as_new_image_cmd_callback (GtkAction *action,
+                                      gpointer   data)
 {
   Gimp       *gimp;
-  GimpBuffer *buffer;
   GtkWidget  *widget;
+  GimpObject *paste;
+  GimpImage  *image = NULL;
   return_if_no_gimp (gimp, data);
   return_if_no_widget (widget, data);
 
-  buffer = gimp_clipboard_get_buffer (gimp);
+  paste = gimp_clipboard_get_object (gimp);
 
-  if (buffer)
+  if (paste)
     {
-      GimpImage *image;
+      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,
+                                              action_data_get_image (data),
+                                              GIMP_BUFFER (paste));
+        }
 
-      image = gimp_image_new_from_buffer (gimp, action_data_get_image (data),
+      g_object_unref (paste);
-                                          buffer);
+    }
-      g_object_unref (buffer);
 
-      gimp_create_display (image->gimp, image, GIMP_UNIT_PIXEL, 1.0,
+  if (image)
+    {
+      gimp_create_display (gimp, image, GIMP_UNIT_PIXEL, 1.0,
                            G_OBJECT (gtk_widget_get_screen (widget)),
                            gimp_widget_get_monitor (widget));
       g_object_unref (image);
@@ -340,43 +401,8 @@ edit_paste_as_new_cmd_callback (GtkAction *action,
   else
     {
       gimp_message_literal (gimp, NULL, GIMP_MESSAGE_WARNING,
-                            _("There is no image data in the clipboard to paste."));
+                            _("There is no image data in the clipboard "
-    }
+                              "to paste."));
-}
-
-void
-edit_paste_as_new_layer_cmd_callback (GtkAction *action,
-                                      gpointer   data)
-{
-  Gimp       *gimp;
-  GimpImage  *image;
-  GimpBuffer *buffer;
-  return_if_no_gimp (gimp, data);
-  return_if_no_image (image, data);
-
-  buffer = gimp_clipboard_get_buffer (gimp);
-
-  if (buffer)
-    {
-      GimpLayer *layer;
-
-      layer = gimp_layer_new_from_buffer (buffer, image,
-                                          gimp_image_get_layer_format (image,
-                                                                       TRUE),
-                                          _("Clipboard"),
-                                          GIMP_OPACITY_OPAQUE,
-                                          GIMP_NORMAL_MODE);
-      g_object_unref (buffer);
-
-      gimp_image_add_layer (image, layer,
-                            GIMP_IMAGE_ACTIVE_PARENT, -1, TRUE);
-
-      gimp_image_flush (image);
-    }
-  else
-    {
-      gimp_message_literal (gimp, NULL, GIMP_MESSAGE_WARNING,
-                            _("There is no image data in the clipboard to paste."));
     }
 }
 
@@ -400,27 +426,6 @@ edit_named_cut_cmd_callback (GtkAction *action,
   gtk_widget_show (dialog);
 }
 
-void
-edit_fade_cmd_callback (GtkAction *action,
-                        gpointer   data)
-{
-  GimpImage *image;
-  GtkWidget *widget;
-  GtkWidget *dialog;
-  return_if_no_image (image, data);
-  return_if_no_widget (widget, data);
-
-  dialog = fade_dialog_new (image, widget);
-
-  if (dialog)
-    {
-      g_signal_connect_object (image, "disconnect",
-                               G_CALLBACK (gtk_widget_destroy),
-                               dialog, G_CONNECT_SWAPPED);
-      gtk_widget_show (dialog);
-    }
-}
-
 void
 edit_named_copy_cmd_callback (GtkAction *action,
                               gpointer   data)
@@ -495,18 +500,22 @@ edit_fill_cmd_callback (GtkAction *action,
                         gint       value,
                         gpointer   data)
 {
-  GimpImage    *image;
+  GimpImage       *image;
-  GimpDrawable *drawable;
+  GimpDrawable    *drawable;
-  GimpFillType  fill_type;
+  GimpFillType     fill_type;
-  GError       *error = NULL;
+  GimpFillOptions *options;
+  GError          *error = NULL;
   return_if_no_drawable (image, drawable, data);
 
   fill_type = (GimpFillType) value;
 
-  if (gimp_edit_fill (image, drawable, action_data_get_context (data),
+  options = gimp_fill_options_new (action_data_get_gimp (data), NULL, FALSE);
-                      fill_type, GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE,
+
-                      &error))
+  if (gimp_fill_options_set_by_fill_type (options,
+                                          action_data_get_context (data),
+                                          fill_type, &error))
     {
+      gimp_edit_fill (image, drawable, options, NULL);
       gimp_image_flush (image);
     }
   else
@@ -515,63 +524,91 @@ edit_fill_cmd_callback (GtkAction *action,
                             error->message);
       g_clear_error (&error);
     }
+
+  g_object_unref (options);
 }
 
 
 /*  private functions  */
 
 static void
-edit_paste (GimpDisplay *display,
+edit_paste (GimpDisplay   *display,
-            gboolean     paste_into)
+            GimpPasteType  paste_type,
+            gboolean       try_svg)
 {
-  GimpImage *image = gimp_display_get_image (display);
+  GimpImage  *image = gimp_display_get_image (display);
-  gchar     *svg;
+  GimpObject *paste;
-  gsize      svg_size;
 
-  svg = gimp_clipboard_get_svg (display->gimp, &svg_size);
+  if (try_svg)
-
-  if (svg)
     {
-      if (gimp_vectors_import_buffer (image, svg, svg_size,
+      gchar *svg;
-                                      TRUE, FALSE,
+      gsize  svg_size;
-                                      GIMP_IMAGE_ACTIVE_PARENT, -1,
+
-                                      NULL, NULL))
+      svg = gimp_clipboard_get_svg (display->gimp, &svg_size);
+
+      if (svg)
         {
-          gimp_image_flush (image);
+          if (gimp_vectors_import_buffer (image, svg, svg_size,
-        }
+                                          TRUE, FALSE,
-
+                                          GIMP_IMAGE_ACTIVE_PARENT, -1,
-      g_free (svg);
+                                          NULL, NULL))
-    }
-  else
-    {
-      GimpBuffer *buffer;
-
-      buffer = gimp_clipboard_get_buffer (display->gimp);
-
-      if (buffer)
-        {
-          GimpDisplayShell *shell = gimp_display_get_shell (display);
-          gint              x, y;
-          gint              width, height;
-
-          gimp_display_shell_untransform_viewport (shell,
-                                                   &x, &y, &width, &height);
-
-          if (gimp_edit_paste (image,
-                               gimp_image_get_active_drawable (image),
-                               buffer, paste_into, x, y, width, height))
             {
               gimp_image_flush (image);
             }
 
-          g_object_unref (buffer);
+          g_free (svg);
+
+          return;
         }
-      else
+    }
+
+  paste = gimp_clipboard_get_object (display->gimp);
+
+  if (paste)
+    {
+      GimpDisplayShell *shell    = gimp_display_get_shell (display);
+      GimpDrawable     *drawable = gimp_image_get_active_drawable (image);
+      gint              x, y;
+      gint              width, height;
+
+      if (drawable)
         {
-          gimp_message_literal (display->gimp, G_OBJECT (display),
+          if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable)))
-                                GIMP_MESSAGE_WARNING,
+            {
-                                _("There is no image data in the clipboard to paste."));
+              gimp_message_literal (display->gimp, G_OBJECT (display),
+                                    GIMP_MESSAGE_INFO,
+                                    _("Pasted as new layer because the "
+                                      "target is a layer group."));
+
+              paste_type = GIMP_PASTE_TYPE_NEW_LAYER;
+            }
+          else if (gimp_item_is_content_locked (GIMP_ITEM (drawable)))
+            {
+              gimp_message_literal (display->gimp, G_OBJECT (display),
+                                    GIMP_MESSAGE_INFO,
+                                    _("Pasted as new layer because the "
+                                      "target's pixels are locked."));
+
+              paste_type = GIMP_PASTE_TYPE_NEW_LAYER;
+            }
         }
+
+      gimp_display_shell_untransform_viewport (shell, &x, &y, &width, &height);
+
+      if (gimp_edit_paste (image, drawable, paste,
+                           paste_type, x, y, width, height))
+        {
+          gimp_image_flush (image);
+        }
+
+      g_object_unref (paste);
+    }
+  else
+    {
+      gimp_message_literal (display->gimp, G_OBJECT (display),
+                            GIMP_MESSAGE_WARNING,
+                            _("There is no image data in the clipboard "
+                              "to paste."));
     }
 }
 

app/actions/edit-commands.h

@@ -29,22 +29,26 @@ void   edit_strong_redo_cmd_callback        (GtkAction *action,
                                              gpointer   data);
 void   edit_undo_clear_cmd_callback         (GtkAction *action,
                                              gpointer   data);
+
 void   edit_fade_cmd_callback               (GtkAction *action,
                                              gpointer   data);
+
 void   edit_cut_cmd_callback                (GtkAction *action,
                                              gpointer   data);
 void   edit_copy_cmd_callback               (GtkAction *action,
                                              gpointer   data);
 void   edit_copy_visible_cmd_callback       (GtkAction *action,
                                              gpointer   data);
+
 void   edit_paste_cmd_callback              (GtkAction *action,
                                              gpointer   data);
 void   edit_paste_into_cmd_callback         (GtkAction *action,
                                              gpointer   data);
-void   edit_paste_as_new_cmd_callback       (GtkAction *action,
-                                             gpointer   data);
 void   edit_paste_as_new_layer_cmd_callback (GtkAction *action,
                                              gpointer   data);
+void   edit_paste_as_new_image_cmd_callback (GtkAction *action,
+                                             gpointer   data);
+
 void   edit_named_cut_cmd_callback          (GtkAction *action,
                                              gpointer   data);
 void   edit_named_copy_cmd_callback         (GtkAction *action,
@@ -53,6 +57,7 @@ void   edit_named_copy_visible_cmd_callback (GtkAction *action,
                                              gpointer   data);
 void   edit_named_paste_cmd_callback        (GtkAction *action,
                                              gpointer   data);
+
 void   edit_clear_cmd_callback              (GtkAction *action,
                                              gpointer   data);
 void   edit_fill_cmd_callback               (GtkAction *action,

app/actions/error-console-commands.c

@@ -75,7 +75,6 @@ error_console_save_cmd_callback (GtkAction *action,
                                  gpointer   data)
 {
   GimpErrorConsole *console = GIMP_ERROR_CONSOLE (data);
-  GtkFileChooser   *chooser;
 
   if (value && ! gtk_text_buffer_get_selection_bounds (console->text_buffer,
                                                        NULL, NULL))
@@ -86,53 +85,50 @@ error_console_save_cmd_callback (GtkAction *action,
       return;
     }
 
-  if (console->file_dialog)
+  if (! console->file_dialog)
     {
-      gtk_window_present (GTK_WINDOW (console->file_dialog));
+      GtkWidget *dialog;
-      return;
+
+      dialog = console->file_dialog =
+        gtk_file_chooser_dialog_new (_("Save Error Log to File"), NULL,
+                                     GTK_FILE_CHOOSER_ACTION_SAVE,
+
+                                     GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+                                     GTK_STOCK_SAVE,   GTK_RESPONSE_OK,
+
+                                     NULL);
+
+      gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
+      gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
+                                               GTK_RESPONSE_OK,
+                                               GTK_RESPONSE_CANCEL,
+                                               -1);
+
+      console->save_selection = value;
+
+      g_object_add_weak_pointer (G_OBJECT (dialog),
+                                 (gpointer) &console->file_dialog);
+
+      gtk_window_set_screen (GTK_WINDOW (dialog),
+                             gtk_widget_get_screen (GTK_WIDGET (console)));
+      gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
+      gtk_window_set_role (GTK_WINDOW (dialog), "gimp-save-errors");
+
+      gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog),
+                                                      TRUE);
+
+      g_signal_connect (dialog, "response",
+                        G_CALLBACK (error_console_save_response),
+                        console);
+      g_signal_connect (dialog, "delete-event",
+                        G_CALLBACK (gtk_true),
+                        NULL);
+
+      gimp_help_connect (dialog, gimp_standard_help_func,
+                         GIMP_HELP_ERRORS_DIALOG, NULL);
     }
 
-  console->file_dialog =
+  gtk_window_present (GTK_WINDOW (console->file_dialog));
-    gtk_file_chooser_dialog_new (_("Save Error Log to File"), NULL,
-                                 GTK_FILE_CHOOSER_ACTION_SAVE,
-
-                                 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
-                                 GTK_STOCK_SAVE,   GTK_RESPONSE_OK,
-
-                                 NULL);
-
-  gtk_dialog_set_alternative_button_order (GTK_DIALOG (console->file_dialog),
-                                           GTK_RESPONSE_OK,
-                                           GTK_RESPONSE_CANCEL,
-                                           -1);
-
-  console->save_selection = value;
-
-  g_object_add_weak_pointer (G_OBJECT (console->file_dialog),
-                             (gpointer) &console->file_dialog);
-
-  chooser = GTK_FILE_CHOOSER (console->file_dialog);
-
-  gtk_window_set_screen (GTK_WINDOW (chooser),
-                         gtk_widget_get_screen (GTK_WIDGET (console)));
-
-  gtk_window_set_position (GTK_WINDOW (chooser), GTK_WIN_POS_MOUSE);
-  gtk_window_set_role (GTK_WINDOW (chooser), "gimp-save-errors");
-
-  gtk_dialog_set_default_response (GTK_DIALOG (chooser), GTK_RESPONSE_OK);
-  gtk_file_chooser_set_do_overwrite_confirmation (chooser, TRUE);
-
-  g_signal_connect (chooser, "response",
-                    G_CALLBACK (error_console_save_response),
-                    console);
-  g_signal_connect (chooser, "delete-event",
-                    G_CALLBACK (gtk_true),
-                    NULL);
-
-  gimp_help_connect (GTK_WIDGET (chooser), gimp_standard_help_func,
-                     GIMP_HELP_ERRORS_DIALOG, NULL);
-
-  gtk_widget_show (GTK_WIDGET (chooser));
 }
 
 
@@ -145,11 +141,9 @@ error_console_save_response (GtkWidget        *dialog,
 {
   if (response_id == GTK_RESPONSE_OK)
     {
-      GFile  *file;
+      GFile  *file  = gtk_file_chooser_get_file (GTK_FILE_CHOOSER (dialog));
       GError *error = NULL;
 
-      file = gtk_file_chooser_get_file (GTK_FILE_CHOOSER (dialog));
-
       if (! gimp_text_buffer_save (GIMP_TEXT_BUFFER (console->text_buffer),
                                    file,
                                    console->save_selection, &error))

app/actions/file-actions.c

@@ -72,7 +72,7 @@ static const GimpActionEntry file_actions[] =
   { "file-create-menu",      NULL, NC_("file-action", "Crea_te")      },
   { "file-open-recent-menu", NULL, NC_("file-action", "Open _Recent") },
 
-  { "file-open", "document-open",
+  { "file-open", GIMP_STOCK_IMAGE_OPEN,
     NC_("file-action", "_Open..."), "<primary>O",
     NC_("file-action", "Open an image file"),
     G_CALLBACK (file_open_cmd_callback),
@@ -96,13 +96,13 @@ static const GimpActionEntry file_actions[] =
     G_CALLBACK (file_create_template_cmd_callback),
     GIMP_HELP_FILE_CREATE_TEMPLATE },
 
-  { "file-revert", "document-revert",
+  { "file-revert", GIMP_STOCK_IMAGE_RELOAD,
     NC_("file-action", "Re_vert"), NULL,
     NC_("file-action", "Reload the image file from disk"),
     G_CALLBACK (file_revert_cmd_callback),
     GIMP_HELP_FILE_REVERT },
 
-  { "file-close-all", "window-close",
+  { "file-close-all", GIMP_STOCK_CLOSE_ALL,
     NC_("file-action", "Close all"), "<primary><shift>W",
     NC_("file-action", "Close all opened images"),
     G_CALLBACK (file_close_all_cmd_callback),
@@ -114,7 +114,7 @@ static const GimpActionEntry file_actions[] =
     G_CALLBACK (file_copy_location_cmd_callback),
     GIMP_HELP_FILE_COPY_LOCATION },
 
-  { "file-show-in-file-manager", "gtk-directory",
+  { "file-show-in-file-manager", GIMP_STOCK_FILE_MANAGER,
     NC_("file-action", "Show in _File Manager"), "<primary><alt>F",
     NC_("file-action", "Show image file location in the file manager"),
     G_CALLBACK (file_show_in_file_manager_cmd_callback),
@@ -156,8 +156,8 @@ static const GimpEnumActionEntry file_save_actions[] =
     GIMP_HELP_FILE_SAVE },
 
   { "file-export", NULL,
-    NC_("file-action", "Export"), "<primary>E",
+    NC_("file-action", "Export..."), "<primary>E",
-    NC_("file-action", "Export the image again"),
+    NC_("file-action", "Export the image"),
     GIMP_SAVE_MODE_EXPORT, FALSE,
     GIMP_HELP_FILE_EXPORT },
 
@@ -217,17 +217,11 @@ file_actions_setup (GimpActionGroup *group)
 
   for (i = 0; i < n_entries; i++)
     {
-      GtkAction *action;
-
       gimp_action_group_set_action_visible (group, entries[i].name, FALSE);
       gimp_action_group_set_action_always_show_image (group, entries[i].name,
                                                       TRUE);
-
+      gimp_action_group_set_action_context (group, entries[i].name,
-      action = gtk_action_group_get_action (GTK_ACTION_GROUP (group),
+                                            gimp_get_user_context (group->gimp));
-                                            entries[i].name);
-      g_object_set (action,
-                    "context", gimp_get_user_context (group->gimp),
-                    NULL);
 
       g_free ((gchar *) entries[i].name);
       if (entries[i].accelerator)
@@ -284,8 +278,9 @@ file_actions_update (GimpActionGroup *group,
 
   show_overwrite =
     (source &&
-     gimp_plug_in_manager_file_has_exporter (gimp->plug_in_manager,
+     gimp_plug_in_manager_file_procedure_find (gimp->plug_in_manager,
-                                             source));
+                                               GIMP_FILE_PROCEDURE_GROUP_EXPORT,
+                                               source, NULL));
 
 #define SET_VISIBLE(action,condition) \
         gimp_action_group_set_action_visible (group, action, (condition) != 0)
@@ -306,6 +301,19 @@ file_actions_update (GimpActionGroup *group,
   SET_SENSITIVE ("file-copy-location",        file || source || export);
   SET_SENSITIVE ("file-show-in-file-manager", file || source || export);
 
+  if (file)
+    {
+      gimp_action_group_set_action_label (group,
+                                          "file-save",
+                                          C_("file-action", "_Save"));
+    }
+  else
+    {
+      gimp_action_group_set_action_label (group,
+                                          "file-save",
+                                          C_("file-action", "_Save..."));
+    }
+
   if (export)
     {
       gchar *label = file_actions_create_label (_("Export to %s"), export);
@@ -321,7 +329,8 @@ file_actions_update (GimpActionGroup *group,
   else
     {
       gimp_action_group_set_action_label (group,
-                                          "file-export", _("Export"));
+                                          "file-export",
+                                          C_("file-action", "Export..."));
     }
 
   /*  needed for the empty display  */

app/actions/file-commands.c

@@ -36,25 +36,28 @@
 #include "core/gimpprogress.h"
 #include "core/gimptemplate.h"
 
-#include "plug-in/gimppluginmanager.h"
+#include "plug-in/gimppluginmanager-file.h"
 
 #include "file/file-open.h"
-#include "file/file-procedure.h"
 #include "file/file-save.h"
 #include "file/gimp-file.h"
 
 #include "widgets/gimpactiongroup.h"
 #include "widgets/gimpclipboard.h"
 #include "widgets/gimpdialogfactory.h"
+#include "widgets/gimpexportdialog.h"
 #include "widgets/gimpfiledialog.h"
 #include "widgets/gimphelp-ids.h"
 #include "widgets/gimpmessagebox.h"
 #include "widgets/gimpmessagedialog.h"
+#include "widgets/gimpopendialog.h"
+#include "widgets/gimpsavedialog.h"
 #include "widgets/gimpwidgets-utils.h"
 
 #include "display/gimpdisplay.h"
 #include "display/gimpdisplay-foreach.h"
 
+#include "dialogs/dialogs.h"
 #include "dialogs/file-save-dialog.h"
 
 #include "actions.h"
@@ -63,9 +66,6 @@
 #include "gimp-intl.h"
 
 
-#define REVERT_DATA_KEY "revert-confirm-dialog"
-
-
 /*  local function prototypes  */
 
 static void        file_open_dialog_show        (Gimp         *gimp,
@@ -87,13 +87,9 @@ static GtkWidget * file_export_dialog_show      (Gimp         *gimp,
 static void        file_save_dialog_response    (GtkWidget    *dialog,
                                                  gint          response_id,
                                                  gpointer      data);
-static void        file_save_dialog_destroyed   (GtkWidget    *dialog,
-                                                 GimpImage    *image);
 static void        file_export_dialog_response  (GtkWidget    *dialog,
                                                  gint          response_id,
                                                  gpointer      data);
-static void        file_export_dialog_destroyed (GtkWidget    *dialog,
-                                                 GimpImage    *image);
 static void        file_new_template_callback   (GtkWidget    *widget,
                                                  const gchar  *name,
                                                  gpointer      data);
@@ -255,8 +251,9 @@ file_save_cmd_callback (GtkAction *action,
           if (file && ! save_proc)
             {
               save_proc =
-                file_procedure_find (image->gimp->plug_in_manager->save_procs,
+                gimp_plug_in_manager_file_procedure_find (image->gimp->plug_in_manager,
-                                     file, NULL);
+                                                          GIMP_FILE_PROCEDURE_GROUP_SAVE,
+                                                          file, NULL);
             }
 
           if (file && save_proc)
@@ -264,23 +261,34 @@ file_save_cmd_callback (GtkAction *action,
               const gchar *version_string;
               gint         rle_version;
               gint         zlib_version;
+              gboolean     compat_possible = FALSE;
 
-              gimp_image_get_xcf_version (image, FALSE, &rle_version,  &version_string);
+              gimp_image_get_xcf_version (image, FALSE,
-              gimp_image_get_xcf_version (image, TRUE,  &zlib_version, NULL);
+                                          &rle_version, &version_string);
+              gimp_image_get_xcf_version (image, TRUE,
+                                          &zlib_version, NULL);
+
+              if (rle_version != zlib_version)
+                compat_possible = TRUE;
+
+              if (gimp_image_get_xcf_compat_mode (image) &&
+                  ! compat_possible)
+                {
+                  gimp_message (image->gimp, G_OBJECT (display),
+                                GIMP_MESSAGE_WARNING,
+                                _("The image uses features from %s and "
+                                  "cannot be saved for older GIMP "
+                                  "versions."),
+                                version_string);
+                }
 
-              if (rle_version == zlib_version && gimp_image_get_xcf_compat_mode (image))
-                gimp_message (image->gimp, G_OBJECT (display), GIMP_MESSAGE_WARNING,
-                              _("The image uses features from %s and "
-                                "cannot be saved for older GIMP "
-                                "versions."),
-                              version_string);
               saved = file_save_dialog_save_image (GIMP_PROGRESS (display),
                                                    gimp, image, file,
                                                    save_proc,
                                                    GIMP_RUN_WITH_LAST_VALS,
                                                    TRUE, FALSE, FALSE,
                                                    gimp_image_get_xcf_compat_mode (image) &&
-                                                   rle_version != zlib_version,
+                                                   compat_possible,
                                                    TRUE);
               break;
             }
@@ -343,8 +351,9 @@ file_save_cmd_callback (GtkAction *action,
         if (file && ! export_proc)
           {
             export_proc =
-              file_procedure_find (image->gimp->plug_in_manager->export_procs,
+              gimp_plug_in_manager_file_procedure_find (image->gimp->plug_in_manager,
-                                   file, NULL);
+                                                        GIMP_FILE_PROCEDURE_GROUP_EXPORT,
+                                                        file, NULL);
           }
 
         if (file && export_proc)
@@ -408,20 +417,20 @@ file_revert_cmd_callback (GtkAction *action,
   if (! file)
     file = gimp_image_get_imported_file (image);
 
-  dialog = g_object_get_data (G_OBJECT (image), REVERT_DATA_KEY);
-
   if (! file)
     {
       gimp_message_literal (image->gimp,
                             G_OBJECT (display), GIMP_MESSAGE_ERROR,
                             _("Revert failed. "
                               "No file name associated with this image."));
+      return;
     }
-  else if (dialog)
+
-    {
+#define REVERT_DIALOG_KEY "gimp-revert-confirm-dialog"
-      gtk_window_present (GTK_WINDOW (dialog));
+
-    }
+  dialog = dialogs_get_dialog (G_OBJECT (image), REVERT_DIALOG_KEY);
-  else
+
+  if (! dialog)
     {
       dialog =
         gimp_message_dialog_new (_("Revert Image"), "document-revert",
@@ -457,10 +466,10 @@ file_revert_cmd_callback (GtkAction *action,
                                    "on disk, you will lose all changes, "
                                    "including all undo information."));
 
-      g_object_set_data (G_OBJECT (image), REVERT_DATA_KEY, dialog);
+      dialogs_attach_dialog (G_OBJECT (image), REVERT_DIALOG_KEY, dialog);
-
-      gtk_widget_show (dialog);
     }
+
+  gtk_window_present (GTK_WINDOW (dialog));
 }
 
 void
@@ -578,9 +587,6 @@ file_open_dialog_show (Gimp        *gimp,
                                            NULL /*ui_manager*/,
                                            "gimp-file-open-dialog", -1, FALSE);
 
-  if (file)
-    g_object_ref (file);
-
   if (dialog)
     {
       if (! file && image)
@@ -591,13 +597,19 @@ file_open_dialog_show (Gimp        *gimp,
                                   GIMP_FILE_OPEN_LAST_FILE_KEY);
 
       if (file)
-        gtk_file_chooser_set_file (GTK_FILE_CHOOSER (dialog), file, NULL);
+        {
+          gtk_file_chooser_set_file (GTK_FILE_CHOOSER (dialog), file, NULL);
+        }
       else if (gimp->default_folder)
-        gtk_file_chooser_set_current_folder_file (GTK_FILE_CHOOSER (dialog),
+        {
-                                                  gimp->default_folder, NULL);
+          gtk_file_chooser_set_current_folder_file (GTK_FILE_CHOOSER (dialog),
+                                                    gimp->default_folder, NULL);
+        }
 
-      gimp_file_dialog_set_open_image (GIMP_FILE_DIALOG (dialog),
+      gtk_window_set_title (GTK_WINDOW (dialog), title);
-                                       image, open_as_layers);
+
+      gimp_open_dialog_set_image (GIMP_OPEN_DIALOG (dialog),
+                                  image, open_as_layers);
 
       gtk_window_set_transient_for (GTK_WINDOW (dialog),
                                     GTK_WINDOW (gtk_widget_get_toplevel (parent)));
@@ -617,7 +629,9 @@ file_save_dialog_show (Gimp        *gimp,
 {
   GtkWidget *dialog;
 
-  dialog = g_object_get_data (G_OBJECT (image), "gimp-file-save-dialog");
+#define SAVE_DIALOG_KEY "gimp-file-save-dialog"
+
+  dialog = dialogs_get_dialog (G_OBJECT (image), SAVE_DIALOG_KEY);
 
   if (! dialog)
     {
@@ -633,15 +647,14 @@ file_save_dialog_show (Gimp        *gimp,
           gtk_window_set_transient_for (GTK_WINDOW (dialog),
                                         GTK_WINDOW (gtk_widget_get_toplevel (parent)));
 
-          g_object_set_data_full (G_OBJECT (image),
+          dialogs_attach_dialog (G_OBJECT (image), SAVE_DIALOG_KEY, dialog);
-                                  "gimp-file-save-dialog", dialog,
+          g_signal_connect_object (image, "disconnect",
-                                  (GDestroyNotify) gtk_widget_destroy);
+                                   G_CALLBACK (gtk_widget_destroy),
+                                   dialog, G_CONNECT_SWAPPED);
+
           g_signal_connect (dialog, "response",
                             G_CALLBACK (file_save_dialog_response),
                             image);
-          g_signal_connect (dialog, "destroy",
-                            G_CALLBACK (file_save_dialog_destroyed),
-                            image);
         }
     }
 
@@ -649,9 +662,9 @@ file_save_dialog_show (Gimp        *gimp,
     {
       gtk_window_set_title (GTK_WINDOW (dialog), title);
 
-      gimp_file_dialog_set_save_image (GIMP_FILE_DIALOG (dialog),
+      gimp_save_dialog_set_image (GIMP_SAVE_DIALOG (dialog),
-                                       gimp, image, save_a_copy, FALSE,
+                                  image, save_a_copy,
-                                       close_after_saving, GIMP_OBJECT (display));
+                                  close_after_saving, GIMP_OBJECT (display));
 
       gtk_window_present (GTK_WINDOW (dialog));
     }
@@ -679,8 +692,8 @@ file_save_dialog_response (GtkWidget *dialog,
       basename = g_path_get_basename (gimp_file_get_utf8_name (file));
       g_object_unref (file);
 
-      other = file_export_dialog_show (file_dialog->image->gimp,
+      other = file_export_dialog_show (GIMP_FILE_DIALOG (file_dialog)->image->gimp,
-                                       file_dialog->image,
+                                       GIMP_FILE_DIALOG (file_dialog)->image,
                                        GTK_WIDGET (parent));
 
       gtk_file_chooser_set_current_folder_file (GTK_FILE_CHOOSER (other),
@@ -692,14 +705,6 @@ file_save_dialog_response (GtkWidget *dialog,
     }
 }
 
-static void
-file_save_dialog_destroyed (GtkWidget *dialog,
-                            GimpImage *image)
-{
-  if (GIMP_FILE_DIALOG (dialog)->image == image)
-    g_object_set_data (G_OBJECT (image), "gimp-file-save-dialog", NULL);
-}
-
 static GtkWidget *
 file_export_dialog_show (Gimp      *gimp,
                          GimpImage *image,
@@ -707,7 +712,9 @@ file_export_dialog_show (Gimp      *gimp,
 {
   GtkWidget *dialog;
 
-  dialog = g_object_get_data (G_OBJECT (image), "gimp-file-export-dialog");
+#define EXPORT_DIALOG_KEY "gimp-file-export-dialog"
+
+  dialog = dialogs_get_dialog (G_OBJECT (image), EXPORT_DIALOG_KEY);
 
   if (! dialog)
     {
@@ -723,23 +730,20 @@ file_export_dialog_show (Gimp      *gimp,
           gtk_window_set_transient_for (GTK_WINDOW (dialog),
                                         GTK_WINDOW (gtk_widget_get_toplevel (parent)));
 
-          g_object_set_data_full (G_OBJECT (image),
+          dialogs_attach_dialog (G_OBJECT (image), EXPORT_DIALOG_KEY, dialog);
-                                  "gimp-file-export-dialog", dialog,
+          g_signal_connect_object (image, "disconnect",
-                                  (GDestroyNotify) gtk_widget_destroy);
+                                   G_CALLBACK (gtk_widget_destroy),
+                                   dialog, G_CONNECT_SWAPPED);
+
           g_signal_connect (dialog, "response",
                             G_CALLBACK (file_export_dialog_response),
                             image);
-          g_signal_connect (dialog, "destroy",
-                            G_CALLBACK (file_export_dialog_destroyed),
-                            image);
         }
     }
 
   if (dialog)
     {
-      gimp_file_dialog_set_save_image (GIMP_FILE_DIALOG (dialog),
+      gimp_export_dialog_set_image (GIMP_EXPORT_DIALOG (dialog), image);
-                                       gimp, image, FALSE, TRUE,
-                                       FALSE, NULL);
 
       gtk_window_present (GTK_WINDOW (dialog));
     }
@@ -767,8 +771,8 @@ file_export_dialog_response (GtkWidget *dialog,
       basename = g_path_get_basename (gimp_file_get_utf8_name (file));
       g_object_unref (file);
 
-      other = file_save_dialog_show (file_dialog->image->gimp,
+      other = file_save_dialog_show (GIMP_FILE_DIALOG (file_dialog)->image->gimp,
-                                     file_dialog->image,
+                                     GIMP_FILE_DIALOG (file_dialog)->image,
                                      GTK_WIDGET (parent),
                                      _("Save Image"),
                                      FALSE, FALSE, NULL);
@@ -782,14 +786,6 @@ file_export_dialog_response (GtkWidget *dialog,
     }
 }
 
-static void
-file_export_dialog_destroyed (GtkWidget *dialog,
-                              GimpImage *image)
-{
-  if (GIMP_FILE_DIALOG (dialog)->image == image)
-    g_object_set_data (G_OBJECT (image), "gimp-file-export-dialog", NULL);
-}
-
 static void
 file_new_template_callback (GtkWidget   *widget,
                             const gchar *name,
@@ -818,8 +814,6 @@ file_revert_confirm_response (GtkWidget   *dialog,
 
   gtk_widget_destroy (dialog);
 
-  g_object_set_data (G_OBJECT (old_image), REVERT_DATA_KEY, NULL);
-
   if (response_id == GTK_RESPONSE_OK)
     {
       Gimp              *gimp = old_image->gimp;

app/actions/filters-actions.c

@@ -24,11 +24,15 @@
 
 #include "actions-types.h"
 
+#include "core/gimp-filter-history.h"
 #include "core/gimpimage.h"
 #include "core/gimplayermask.h"
 
+#include "pdb/gimpprocedure.h"
+
 #include "widgets/gimpactiongroup.h"
 #include "widgets/gimphelp-ids.h"
+#include "widgets/gimpuimanager.h"
 
 #include "actions.h"
 #include "filters-actions.h"
@@ -37,6 +41,60 @@
 #include "gimp-intl.h"
 
 
+/*  local function prototypes  */
+
+static void   filters_actions_history_changed (Gimp            *gimp,
+                                               GimpActionGroup *group);
+
+
+/*  private variables  */
+
+static const GimpActionEntry filters_menu_actions[] =
+{
+  { "filters-menu",                 NULL, NC_("filters-action",
+                                              "Filte_rs")          },
+  { "filters-recent-menu",          NULL, NC_("filters-action",
+                                              "Recently Used")     },
+  { "filters-blur-menu",            NULL, NC_("filters-action",
+                                              "_Blur")             },
+  { "filters-noise-menu",           NULL, NC_("filters-action",
+                                              "_Noise")            },
+  { "filters-edge-detect-menu",     NULL, NC_("filters-action",
+                                              "Edge-De_tect")      },
+  { "filters-enhance-menu",         NULL, NC_("filters-action",
+                                              "En_hance")          },
+  { "filters-combine-menu",         NULL, NC_("filters-action",
+                                              "C_ombine")          },
+  { "filters-generic-menu",         NULL, NC_("filters-action",
+                                              "_Generic")          },
+  { "filters-light-shadow-menu",    NULL, NC_("filters-action",
+                                              "_Light and Shadow") },
+  { "filters-distorts-menu",        NULL, NC_("filters-action",
+                                              "_Distorts")         },
+  { "filters-artistic-menu",        NULL, NC_("filters-action",
+                                              "_Artistic")         },
+  { "filters-decor-menu",           NULL, NC_("filters-action",
+                                              "_Decor")            },
+  { "filters-map-menu",             NULL, NC_("filters-action",
+                                              "_Map")              },
+  { "filters-render-menu",          NULL, NC_("filters-action",
+                                              "_Render")           },
+  { "filters-render-clouds-menu",   NULL, NC_("filters-action",
+                                              "_Clouds")           },
+  { "filters-render-fractals-menu", NULL, NC_("filters-action",
+                                              "_Fractals")         },
+  { "filters-render-nature-menu",   NULL, NC_("filters-action",
+                                              "_Nature")           },
+  { "filters-render-noise-menu",    NULL, NC_("filters-action",
+                                              "N_oise")            },
+  { "filters-render-pattern-menu",  NULL, NC_("filters-action",
+                                              "_Pattern")          },
+  { "filters-web-menu",             NULL, NC_("filters-action",
+                                              "_Web")              },
+  { "filters-animation-menu",       NULL, NC_("filters-action",
+                                              "An_imation")        }
+};
+
 static const GimpStringActionEntry filters_actions[] =
 {
   { "filters-alien-map", GIMP_STOCK_GEGL,
@@ -65,7 +123,7 @@ static const GimpStringActionEntry filters_actions[] =
     NULL /* FIXME GIMP_HELP_FILTER_BUMP_MAP */ },
 
   { "filters-c2g", GIMP_STOCK_GEGL,
-    NC_("filters-action", "Color to Gray..."), NULL, NULL,
+    NC_("filters-action", "_Color to Gray..."), NULL, NULL,
     "gegl:c2g",
     NULL /* FIXME GIMP_HELP_FILTER_C2G */ },
 
@@ -129,6 +187,11 @@ static const GimpStringActionEntry filters_actions[] =
     "gegl:deinterlace",
     NULL /* FIXME GIMP_HELP_FILTER_DEINTERLACE */ },
 
+  { "filters-desaturate", GIMP_STOCK_TOOL_DESATURATE,
+    NC_("filters-action", "_Desaturate..."), NULL, NULL,
+    "gimp:desaturate",
+    GIMP_HELP_TOOL_DESATURATE },
+
   { "filters-difference-of-gaussians", GIMP_STOCK_GEGL,
     NC_("filters-action", "Difference of Gaussians..."), NULL, NULL,
     "gegl:difference-of-gaussians",
@@ -175,12 +238,12 @@ static const GimpStringActionEntry filters_actions[] =
     NULL /* FIXME GIMP_HELP_FILTER_EMBOSS */ },
 
   { "filters-engrave", GIMP_STOCK_GEGL,
-    NC_("filters-action", "_En_grave..."), NULL, NULL,
+    NC_("filters-action", "En_grave..."), NULL, NULL,
     "gegl:engrave",
     NULL /* FIXME GIMP_HELP_FILTER_ENGRAVE */ },
 
   { "filters-exposure", GIMP_STOCK_GEGL,
-    NC_("filters-action", "_E_xposure..."), NULL, NULL,
+    NC_("filters-action", "E_xposure..."), NULL, NULL,
     "gegl:exposure",
     NULL /* FIXME GIMP_HELP_FILTER_EXPOSURE */ },
 
@@ -194,11 +257,26 @@ static const GimpStringActionEntry filters_actions[] =
     "gegl:gaussian-blur",
     NULL /* FIXME GIMP_HELP_FILTER_GAUSSIAN_BLUR */ },
 
+  { "filters-gaussian-blur-selective", GIMP_STOCK_GEGL,
+    NC_("filters-action", "_Selective Gaussian Blur..."), NULL, NULL,
+    "gegl:gaussian-blur-selective",
+    NULL /* FIXME GIMP_HELP_FILTER_GAUSSIAN_BLUR_SELECTIVE */ },
+
+  { "filters-gegl-graph", GIMP_STOCK_GEGL,
+    NC_("filters-action", "_GEGL graph..."), NULL, NULL,
+    "gegl:gegl",
+    NULL /* FIXME GIMP_HELP_FILTER_GEGL_GRAPH */ },
+
   { "filters-grid", GIMP_STOCK_GRID,
     NC_("filters-action", "_Grid..."), NULL, NULL,
     "gegl:grid",
     NULL /* FIXME GIMP_HELP_FILTER_GAUSSIAN_GRID */ },
 
+  { "filters-high-pass", GIMP_STOCK_GEGL,
+    NC_("filters-action", "_High Pass..."), NULL, NULL,
+    "gegl:high-pass",
+    NULL /* FIXME GIMP_HELP_FILTER_HIGH_PASS */ },
+
   { "filters-illusion", GIMP_STOCK_GEGL,
     NC_("filters-action", "_Illusion..."), NULL, NULL,
     "gegl:illusion",
@@ -219,8 +297,13 @@ static const GimpStringActionEntry filters_actions[] =
     "gegl:lens-flare",
     NULL /* FIXME GIMP_HELP_FILTER_LENS_FLARE */ },
 
+  { "filters-maze", GIMP_STOCK_GEGL,
+    NC_("filters-action", "_Maze..."), NULL, NULL,
+    "gegl:maze",
+    NULL /* FIXME GIMP_HELP_FILTER_MAZE */ },
+
   { "filters-mono-mixer", GIMP_STOCK_GEGL,
-    NC_("filters-action", "Mono Mixer..."), NULL, NULL,
+    NC_("filters-action", "_Mono Mixer..."), NULL, NULL,
     "gegl:mono-mixer",
     NULL /* FIXME GIMP_HELP_FILTER_MONO_MIXER */ },
 
@@ -334,6 +417,11 @@ static const GimpStringActionEntry filters_actions[] =
     "gegl:polar-coordinates",
     NULL /* FIXME GIMP_HELP_FILTER_POLAR_COORDINATES */ },
 
+  { "filters-posterize", GIMP_STOCK_TOOL_POSTERIZE,
+    NC_("filters-action", "_Posterize..."), NULL, NULL,
+    "gimp:posterize",
+    GIMP_HELP_TOOL_POSTERIZE },
+
   { "filters-red-eye-removal", GIMP_STOCK_GEGL,
     NC_("filters-action", "_Red Eye Removal..."), NULL, NULL,
     "gegl:red-eye-removal",
@@ -344,10 +432,20 @@ static const GimpStringActionEntry filters_actions[] =
     "gegl:ripple",
     NULL /* FIXME GIMP_HELP_FILTER_RIPPLE */ },
 
+  { "filters-saturation", GIMP_STOCK_GEGL,
+    NC_("filters-action", "Sat_uration..."), NULL, NULL,
+    "gegl:saturation",
+    NULL /* FIXME GIMP_HELP_FILTER_SATURATION */ },
+
   { "filters-semi-flatten", GIMP_STOCK_GEGL,
     NC_("filters-action", "_Semi-Flatten..."), NULL, NULL,
     "gimp:semi-flatten",
-    NULL /* FIXME GIMP_HELP_FILTER_POLAR_COORDINATES */ },
+    NULL /* FIXME GIMP_HELP_FILTER_SEMI_FLATTEN */ },
+
+  { "filters-sepia", GIMP_STOCK_GEGL,
+    NC_("filters-action", "_Sepia..."), NULL, NULL,
+    "gegl:sepia",
+    NULL /* FIXME GIMP_HELP_FILTER_SEPIA */ },
 
   { "filters-shift", GIMP_STOCK_GEGL,
     NC_("filters-action", "_Shift..."), NULL, NULL,
@@ -375,7 +473,7 @@ static const GimpStringActionEntry filters_actions[] =
     NULL /* FIXME GIMP_HELP_FILTER_STRETCH_CONTRAST_HSV */ },
 
   { "filters-supernova", GIMP_STOCK_GEGL,
-    NC_("filters-action", "_Super_nova..."), NULL, NULL,
+    NC_("filters-action", "Super_nova..."), NULL, NULL,
     "gegl:supernova",
     NULL /* FIXME GIMP_HELP_FILTER_SUPERNOVA */ },
 
@@ -432,19 +530,47 @@ static const GimpStringActionEntry filters_actions[] =
   { "filters-wind", GIMP_STOCK_GEGL,
     NC_("filters-action", "W_ind..."), NULL, NULL,
     "gegl:wind",
-    NULL /* FIXME GIMP_HELP_FILTER_WIND */ },
+    NULL /* FIXME GIMP_HELP_FILTER_WIND */ }
 };
 
+static const GimpEnumActionEntry filters_repeat_actions[] =
+{
+  { "filters-repeat", "system-run",
+    NC_("filters-action", "Re_peat Last"), "<primary>F",
+    NC_("filters-action",
+        "Rerun the last used filter using the same settings"),
+    GIMP_RUN_WITH_LAST_VALS, FALSE,
+    GIMP_HELP_FILTER_REPEAT },
+
+  { "filters-reshow", GIMP_STOCK_RESHOW_FILTER,
+    NC_("filters-action", "R_e-Show Last"), "<primary><shift>F",
+    NC_("filters-action", "Show the last used filter dialog again"),
+    GIMP_RUN_INTERACTIVE, FALSE,
+    GIMP_HELP_FILTER_RESHOW }
+};
+
+
 void
 filters_actions_setup (GimpActionGroup *group)
 {
-  gint i;
+  GimpProcedureActionEntry *entries;
+  gint                      n_entries;
+  gint                      i;
+
+  gimp_action_group_add_actions (group, "filters-action",
+                                 filters_menu_actions,
+                                 G_N_ELEMENTS (filters_menu_actions));
 
   gimp_action_group_add_string_actions (group, "filters-action",
                                         filters_actions,
                                         G_N_ELEMENTS (filters_actions),
                                         G_CALLBACK (filters_filter_cmd_callback));
 
+  gimp_action_group_add_enum_actions (group, "filters-action",
+                                      filters_repeat_actions,
+                                      G_N_ELEMENTS (filters_repeat_actions),
+                                      G_CALLBACK (filters_repeat_cmd_callback));
+
   for (i = 0; i < G_N_ELEMENTS (filters_actions); i++)
     {
       const GimpStringActionEntry *entry = &filters_actions[i];
@@ -456,6 +582,38 @@ filters_actions_setup (GimpActionGroup *group)
         gimp_action_group_set_action_tooltip (group, entry->name,
                                               description);
     }
+
+  n_entries = gimp_filter_history_size (group->gimp);
+
+  entries = g_new0 (GimpProcedureActionEntry, n_entries);
+
+  for (i = 0; i < n_entries; i++)
+    {
+      entries[i].name        = g_strdup_printf ("filters-recent-%02d", i + 1);
+      entries[i].icon_name   = NULL;
+      entries[i].label       = "";
+      entries[i].accelerator = "";
+      entries[i].tooltip     = NULL;
+      entries[i].procedure   = NULL;
+      entries[i].help_id     = GIMP_HELP_FILTER_RESHOW;
+    }
+
+  gimp_action_group_add_procedure_actions (group, entries, n_entries,
+                                           G_CALLBACK (filters_history_cmd_callback));
+
+  for (i = 0; i < n_entries; i++)
+    {
+      gimp_action_group_set_action_visible (group, entries[i].name, FALSE);
+      g_free ((gchar *) entries[i].name);
+    }
+
+  g_free (entries);
+
+  g_signal_connect_object (group->gimp, "filter-history-changed",
+                           G_CALLBACK (filters_actions_history_changed),
+                           group, 0);
+
+  filters_actions_history_changed (group->gimp, group);
 }
 
 void
@@ -503,6 +661,7 @@ filters_actions_update (GimpActionGroup *group,
   SET_SENSITIVE ("filters-bump-map",                writable);
   SET_SENSITIVE ("filters-c2g",                     writable && !gray);
   SET_SENSITIVE ("filters-cartoon",                 writable);
+  SET_SENSITIVE ("filters-channel-mixer",           writable);
   SET_SENSITIVE ("filters-checkerboard",            writable);
   SET_SENSITIVE ("filters-color-enhance",           writable && !gray);
   SET_SENSITIVE ("filters-color-exchange",          writable);
@@ -513,6 +672,7 @@ filters_actions_update (GimpActionGroup *group,
   SET_SENSITIVE ("filters-convolution-matrix",      writable);
   SET_SENSITIVE ("filters-cubism",                  writable);
   SET_SENSITIVE ("filters-deinterlace",             writable);
+  SET_SENSITIVE ("filters-desaturate",              writable && !gray);
   SET_SENSITIVE ("filters-difference-of-gaussians", writable);
   SET_SENSITIVE ("filters-diffraction-patterns",    writable);
   SET_SENSITIVE ("filters-displace",                writable);
@@ -526,11 +686,15 @@ filters_actions_update (GimpActionGroup *group,
   SET_SENSITIVE ("filters-exposure",                writable);
   SET_SENSITIVE ("filters-fractal-trace",           writable);
   SET_SENSITIVE ("filters-gaussian-blur",           writable);
+  SET_SENSITIVE ("filters-gaussian-blur-selective", writable);
+  SET_SENSITIVE ("filters-gegl-graph",              writable);
   SET_SENSITIVE ("filters-grid",                    writable);
+  SET_SENSITIVE ("filters-high-pass",               writable);
   SET_SENSITIVE ("filters-illusion",                writable);
   SET_SENSITIVE ("filters-kaleidoscope",            writable);
   SET_SENSITIVE ("filters-lens-distortion",         writable);
   SET_SENSITIVE ("filters-lens-flare",              writable);
+  SET_SENSITIVE ("filters-maze",                    writable);
   SET_SENSITIVE ("filters-mono-mixer",              writable && !gray);
   SET_SENSITIVE ("filters-mosaic",                  writable);
   SET_SENSITIVE ("filters-motion-blur-circular",    writable);
@@ -554,9 +718,12 @@ filters_actions_update (GimpActionGroup *group,
   SET_SENSITIVE ("filters-pixelize",                writable);
   SET_SENSITIVE ("filters-plasma",                  writable);
   SET_SENSITIVE ("filters-polar-coordinates",       writable);
+  SET_SENSITIVE ("filters-posterize",               writable);
   SET_SENSITIVE ("filters-red-eye-removal",         writable && !gray);
   SET_SENSITIVE ("filters-ripple",                  writable);
+  SET_SENSITIVE ("filters-saturation",              writable && !gray);
   SET_SENSITIVE ("filters-semi-flatten",            writable && alpha);
+  SET_SENSITIVE ("filters-sepia",                   writable && !gray);
   SET_SENSITIVE ("filters-shift",                   writable);
   SET_SENSITIVE ("filters-sinus",                   writable);
   SET_SENSITIVE ("filters-softglow",                writable);
@@ -568,6 +735,7 @@ filters_actions_update (GimpActionGroup *group,
   SET_SENSITIVE ("filters-tile-paper",              writable);
   SET_SENSITIVE ("filters-tile-seamless",           writable);
   SET_SENSITIVE ("filters-unsharp-mask",            writable);
+  SET_SENSITIVE ("filters-value-propagate",         writable);
   SET_SENSITIVE ("filters-video-degradation",       writable);
   SET_SENSITIVE ("filters-vignette",                writable);
   SET_SENSITIVE ("filters-waves",                   writable);
@@ -575,4 +743,181 @@ filters_actions_update (GimpActionGroup *group,
   SET_SENSITIVE ("filters-wind",                    writable);
 
 #undef SET_SENSITIVE
+
+  {
+    GimpProcedure *proc = gimp_filter_history_nth (group->gimp, 0);
+    gint           i;
+
+    if (proc && gimp_procedure_get_sensitive (proc, GIMP_OBJECT (drawable)))
+      {
+        gimp_action_group_set_action_sensitive (group, "filters-repeat", TRUE);
+        gimp_action_group_set_action_sensitive (group, "filters-reshow", TRUE);
+      }
+    else
+      {
+        gimp_action_group_set_action_sensitive (group, "filters-repeat", FALSE);
+        gimp_action_group_set_action_sensitive (group, "filters-reshow", FALSE);
+      }
+
+    for (i = 0; i < gimp_filter_history_length (group->gimp); i++)
+      {
+        gchar    *name = g_strdup_printf ("filters-recent-%02d", i + 1);
+        gboolean  sensitive;
+
+        proc = gimp_filter_history_nth (group->gimp, i);
+
+        sensitive = gimp_procedure_get_sensitive (proc, GIMP_OBJECT (drawable));
+
+        gimp_action_group_set_action_sensitive (group, name, sensitive);
+
+        g_free (name);
+      }
+  }
+}
+
+static GimpActionGroup *
+filters_actions_get_plug_in_group (GimpActionGroup *group)
+{
+  GList *list;
+
+  for (list = gimp_ui_managers_from_name ("<Image>");
+       list;
+       list = g_list_next (list))
+    {
+      GimpUIManager *manager = list->data;
+
+      /* if this is our UI manager */
+      if (gimp_ui_manager_get_action_group (manager, "filters") == group)
+        return gimp_ui_manager_get_action_group (manager, "plug-in");
+    }
+
+  /* this happens during initial UI manager construction */
+  return NULL;
+}
+
+static void
+filters_actions_history_changed (Gimp            *gimp,
+                                 GimpActionGroup *group)
+{
+  GimpProcedure   *proc;
+  GimpActionGroup *plug_in_group;
+  gint             i;
+
+  plug_in_group = filters_actions_get_plug_in_group (group);
+
+  proc = gimp_filter_history_nth (gimp, 0);
+
+  if (proc)
+    {
+      GtkAction   *actual_action = NULL;
+      const gchar *label;
+      gchar       *repeat;
+      gchar       *reshow;
+      gboolean     sensitive = FALSE;
+
+      label = gimp_procedure_get_label (proc);
+
+      repeat = g_strdup_printf (_("Re_peat \"%s\""),  label);
+      reshow = g_strdup_printf (_("R_e-Show \"%s\""), label);
+
+      gimp_action_group_set_action_label (group, "filters-repeat", repeat);
+      gimp_action_group_set_action_label (group, "filters-reshow", reshow);
+
+      g_free (repeat);
+      g_free (reshow);
+
+      if (g_str_has_prefix (gimp_object_get_name (proc), "filters-"))
+        {
+          actual_action =
+            gtk_action_group_get_action (GTK_ACTION_GROUP (group),
+                                         gimp_object_get_name (proc));
+        }
+      else if (plug_in_group)
+        {
+          /*  copy the sensitivity of the plug-in procedure's actual
+           *  action instead of calling filters_actions_update()
+           *  because doing the latter would set the sensitivity of
+           *  this image's action on all images' actions. See bug
+           *  #517683.
+           */
+          actual_action =
+            gtk_action_group_get_action (GTK_ACTION_GROUP (plug_in_group),
+                                         gimp_object_get_name (proc));
+        }
+
+      if (actual_action)
+        sensitive = gtk_action_get_sensitive (actual_action);
+
+      gimp_action_group_set_action_sensitive (group, "filters-repeat",
+                                              sensitive);
+      gimp_action_group_set_action_sensitive (group, "filters-reshow",
+                                              sensitive);
+    }
+  else
+    {
+      gimp_action_group_set_action_label (group, "filters-repeat",
+                                          _("Repeat Last"));
+      gimp_action_group_set_action_label (group, "filters-reshow",
+                                          _("Re-Show Last"));
+
+      gimp_action_group_set_action_sensitive (group, "filters-repeat", FALSE);
+      gimp_action_group_set_action_sensitive (group, "filters-reshow", FALSE);
+    }
+
+  for (i = 0; i < gimp_filter_history_length (gimp); i++)
+    {
+      GtkAction   *action;
+      GtkAction   *actual_action = NULL;
+      const gchar *label;
+      gchar       *name;
+      gboolean     sensitive = FALSE;
+
+      name = g_strdup_printf ("filters-recent-%02d", i + 1);
+      action = gtk_action_group_get_action (GTK_ACTION_GROUP (group), name);
+      g_free (name);
+
+      proc = gimp_filter_history_nth (gimp, i);
+
+      label = gimp_procedure_get_menu_label (proc);
+
+      if (g_str_has_prefix (gimp_object_get_name (proc), "filters-"))
+        {
+          actual_action =
+            gtk_action_group_get_action (GTK_ACTION_GROUP (group),
+                                         gimp_object_get_name (proc));
+        }
+      else if (plug_in_group)
+        {
+          /*  see comment above  */
+          actual_action =
+            gtk_action_group_get_action (GTK_ACTION_GROUP (plug_in_group),
+                                         gimp_object_get_name (proc));
+        }
+
+      if (actual_action)
+        sensitive = gtk_action_get_sensitive (actual_action);
+
+      g_object_set (action,
+                    "visible",   TRUE,
+                    "sensitive", sensitive,
+                    "procedure", proc,
+                    "label",     label,
+                    "icon-name", gimp_viewable_get_icon_name (GIMP_VIEWABLE (proc)),
+                    "tooltip",   gimp_procedure_get_blurb (proc),
+                    NULL);
+    }
+
+  for (; i < gimp_filter_history_size (gimp); i++)
+    {
+      GtkAction *action;
+      gchar     *name = g_strdup_printf ("filters-recent-%02d", i + 1);
+
+      action = gtk_action_group_get_action (GTK_ACTION_GROUP (group), name);
+      g_free (name);
+
+      g_object_set (action,
+                    "visible",   FALSE,
+                    "procedure", NULL,
+                    NULL);
+    }
 }

app/actions/filters-commands.c

@@ -21,21 +21,18 @@
 #include <gtk/gtk.h>
 
 #include "libgimpbase/gimpbase.h"
+#include "libgimpwidgets/gimpwidgets.h"
 
 #include "actions-types.h"
 
 #include "core/gimp.h"
-#include "core/gimpcontext.h"
+#include "core/gimp-filter-history.h"
-#include "core/gimpimage.h"
+#include "core/gimpprogress.h"
-#include "core/gimptoolinfo.h"
-
-#include "tools/gimpoperationtool.h"
-#include "tools/tool_manager.h"
 
 #include "actions.h"
 #include "filters-commands.h"
-
+#include "gimpgeglprocedure.h"
-#include "gimp-intl.h"
+#include "procedure-commands.h"
 
 
 /*  public functions  */
@@ -45,51 +42,85 @@ filters_filter_cmd_callback (GtkAction   *action,
                              const gchar *operation,
                              gpointer     data)
 {
-  GimpImage    *image;
+  GimpDisplay   *display;
-  GimpDrawable *drawable;
+  GimpProcedure *procedure;
-  GimpDisplay  *display;
-  GimpTool     *active_tool;
-  return_if_no_drawable (image, drawable, data);
   return_if_no_display (display, data);
 
-  active_tool = tool_manager_get_active (image->gimp);
+  procedure = gimp_gegl_procedure_new (action_data_get_gimp (data),
+                                       operation,
+                                       gtk_action_get_name (action),
+                                       gtk_action_get_label (action),
+                                       gtk_action_get_tooltip (action),
+                                       gtk_action_get_icon_name (action),
+                                       g_object_get_qdata (G_OBJECT (action),
+                                                           GIMP_HELP_ID));
 
-  if (G_TYPE_FROM_INSTANCE (active_tool) != GIMP_TYPE_OPERATION_TOOL)
+  gimp_filter_history_add (action_data_get_gimp (data), procedure);
+  filters_history_cmd_callback (NULL, procedure, data);
+
+  g_object_unref (procedure);
+}
+
+void
+filters_repeat_cmd_callback (GtkAction *action,
+                             gint       value,
+                             gpointer   data)
+{
+  Gimp          *gimp;
+  GimpDisplay   *display;
+  GimpRunMode    run_mode;
+  GimpProcedure *procedure;
+  return_if_no_gimp (gimp, data);
+  return_if_no_display (display, data);
+
+  run_mode = (GimpRunMode) value;
+
+  procedure = gimp_filter_history_nth (gimp, 0);
+
+  if (procedure)
     {
-      GimpToolInfo *tool_info = gimp_get_tool_info (image->gimp,
+      GimpValueArray *args;
-                                                    "gimp-operation-tool");
 
-      if (GIMP_IS_TOOL_INFO (tool_info))
+      args = procedure_commands_get_display_args (procedure, display);
-        gimp_context_set_tool (action_data_get_context (data), tool_info);
-    }
-  else
-    {
-      gimp_context_tool_changed (action_data_get_context (data));
-    }
 
-  active_tool = tool_manager_get_active (image->gimp);
+      if (args)
-
-  if (GIMP_IS_OPERATION_TOOL (active_tool))
-    {
-      gchar       *label    = gimp_strip_uline (gtk_action_get_label (action));
-      const gchar *ellipsis = _("...");
-      gint         label_len;
-      gint         ellipsis_len;
-
-      label_len    = strlen (label);
-      ellipsis_len = strlen (ellipsis);
-
-      if (label_len > ellipsis_len &&
-          strcmp (label + label_len - ellipsis_len, ellipsis) == 0)
         {
-          label[label_len - ellipsis_len] = '\0';
+          if (procedure_commands_run_procedure (procedure, gimp,
+                                                GIMP_PROGRESS (display),
+                                                run_mode, args,
+                                                display))
+            {
+              gimp_filter_history_add (gimp, procedure);
+            }
+
+          gimp_value_array_unref (args);
         }
-
+    }
-      gimp_operation_tool_set_operation (GIMP_OPERATION_TOOL (active_tool),
+}
-                                         operation, label,
+
-                                         gtk_action_get_icon_name (action));
+void
-      tool_manager_initialize_active (image->gimp, display);
+filters_history_cmd_callback (GtkAction     *action,
-
+                              GimpProcedure *procedure,
-      g_free (label);
+                              gpointer       data)
+{
+  Gimp           *gimp;
+  GimpDisplay    *display;
+  GimpValueArray *args;
+  return_if_no_gimp (gimp, data);
+  return_if_no_display (display, data);
+
+  args = procedure_commands_get_display_args (procedure, display);
+
+  if (args)
+    {
+      if (procedure_commands_run_procedure (procedure, gimp,
+                                            GIMP_PROGRESS (display),
+                                            GIMP_RUN_INTERACTIVE, args,
+                                            display))
+        {
+          gimp_filter_history_add (gimp, procedure);
+        }
+
+      gimp_value_array_unref (args);
     }
 }

app/actions/filters-commands.h

@@ -19,9 +19,16 @@
 #define __FILTERS_COMMANDS_H__
 
 
-void   filters_filter_cmd_callback (GtkAction   *action,
+void   filters_filter_cmd_callback  (GtkAction     *action,
-                                    const gchar *operation,
+                                     const gchar   *operation,
-                                    gpointer     data);
+                                     gpointer       data);
+
+void   filters_repeat_cmd_callback  (GtkAction     *action,
+                                     gint           value,
+                                     gpointer       data);
+void   filters_history_cmd_callback (GtkAction     *action,
+                                     GimpProcedure *procedure,
+                                     gpointer       data);
 
 
 #endif /* __FILTERS_COMMANDS_H__ */

app/actions/fonts-actions.c

@@ -40,7 +40,7 @@
 
 static const GimpActionEntry fonts_actions[] =
 {
-  { "fonts-popup", GIMP_STOCK_FONT,
+  { "fonts-popup", "gtk-select-font",
     NC_("fonts-action", "Fonts Menu"), NULL, NULL, NULL,
     GIMP_HELP_FONT_DIALOG },
 

app/actions/fonts-commands.c

@@ -26,13 +26,9 @@
 
 #include "text/gimp-fonts.h"
 
-#include "widgets/gimpfontview.h"
-
 #include "actions.h"
 #include "fonts-commands.h"
 
-#include "gimp-intl.h"
-
 
 /*  public functionss */
 
@@ -43,5 +39,5 @@ fonts_refresh_cmd_callback (GtkAction *action,
   GimpContext *context = action_data_get_context (data);
 
   if (context)
-    gimp_fonts_load (context->gimp);
+    gimp_fonts_load (context->gimp, NULL);
 }

app/actions/gimpgeglprocedure.c

@@ -0,0 +1,405 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * gimpgeglprocedure.c
+ * Copyright (C) 2016 Michael Natterer <mitch@gimp.org>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <string.h>
+
+#include <gegl.h>
+#include <gtk/gtk.h>
+
+#include "libgimpbase/gimpbase.h"
+#include "libgimpconfig/gimpconfig.h"
+
+#include "actions-types.h"
+
+#include "core/gimp.h"
+#include "core/gimp-memsize.h"
+#include "core/gimpcontainer.h"
+#include "core/gimpcontext.h"
+#include "core/gimpdrawable-operation.h"
+#include "core/gimpimage.h"
+#include "core/gimplayermask.h"
+#include "core/gimpparamspecs.h"
+#include "core/gimpsettings.h"
+#include "core/gimptoolinfo.h"
+
+#include "gegl/gimp-gegl-config.h"
+
+#include "display/gimpdisplay.h"
+
+#include "tools/gimpoperationtool.h"
+#include "tools/tool_manager.h"
+
+#include "gimpgeglprocedure.h"
+
+#include "gimp-intl.h"
+
+
+static void     gimp_gegl_procedure_finalize            (GObject        *object);
+
+static gint64   gimp_gegl_procedure_get_memsize         (GimpObject     *object,
+                                                         gint64         *gui_size);
+
+static gchar  * gimp_gegl_procedure_get_description     (GimpViewable   *viewable,
+                                                         gchar         **tooltip);
+
+static const gchar * gimp_gegl_procedure_get_label      (GimpProcedure  *procedure);
+static const gchar * gimp_gegl_procedure_get_menu_label (GimpProcedure  *procedure);
+static const gchar * gimp_gegl_procedure_get_help_id    (GimpProcedure  *procedure);
+static gboolean      gimp_gegl_procedure_get_sensitive  (GimpProcedure  *procedure,
+                                                         GimpObject     *object);
+static GimpValueArray * gimp_gegl_procedure_execute     (GimpProcedure  *procedure,
+                                                         Gimp           *gimp,
+                                                         GimpContext    *context,
+                                                         GimpProgress   *progress,
+                                                         GimpValueArray *args,
+                                                         GError        **error);
+static void     gimp_gegl_procedure_execute_async       (GimpProcedure  *procedure,
+                                                         Gimp           *gimp,
+                                                         GimpContext    *context,
+                                                         GimpProgress   *progress,
+                                                         GimpValueArray *args,
+                                                         GimpObject     *display);
+
+
+G_DEFINE_TYPE (GimpGeglProcedure, gimp_gegl_procedure,
+               GIMP_TYPE_PROCEDURE)
+
+#define parent_class gimp_gegl_procedure_parent_class
+
+
+static void
+gimp_gegl_procedure_class_init (GimpGeglProcedureClass *klass)
+{
+  GObjectClass       *object_class      = G_OBJECT_CLASS (klass);
+  GimpObjectClass    *gimp_object_class = GIMP_OBJECT_CLASS (klass);
+  GimpViewableClass  *viewable_class    = GIMP_VIEWABLE_CLASS (klass);
+  GimpProcedureClass *proc_class        = GIMP_PROCEDURE_CLASS (klass);
+
+  object_class->finalize            = gimp_gegl_procedure_finalize;
+
+  gimp_object_class->get_memsize    = gimp_gegl_procedure_get_memsize;
+
+  viewable_class->default_icon_name = "gimp-gegl";
+  viewable_class->get_description   = gimp_gegl_procedure_get_description;
+
+  proc_class->get_label             = gimp_gegl_procedure_get_label;
+  proc_class->get_menu_label        = gimp_gegl_procedure_get_menu_label;
+  proc_class->get_help_id           = gimp_gegl_procedure_get_help_id;
+  proc_class->get_sensitive         = gimp_gegl_procedure_get_sensitive;
+  proc_class->execute               = gimp_gegl_procedure_execute;
+  proc_class->execute_async         = gimp_gegl_procedure_execute_async;
+}
+
+static void
+gimp_gegl_procedure_init (GimpGeglProcedure *proc)
+{
+}
+
+static void
+gimp_gegl_procedure_finalize (GObject *object)
+{
+  GimpGeglProcedure *proc = GIMP_GEGL_PROCEDURE (object);
+
+  g_free (proc->menu_label);
+  g_free (proc->label);
+  g_free (proc->help_id);
+
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static gint64
+gimp_gegl_procedure_get_memsize (GimpObject *object,
+                                    gint64     *gui_size)
+{
+  GimpGeglProcedure *proc    = GIMP_GEGL_PROCEDURE (object);
+  gint64             memsize = 0;
+
+  memsize += gimp_string_get_memsize (proc->menu_label);
+  memsize += gimp_string_get_memsize (proc->label);
+
+  return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object,
+                                                                  gui_size);
+}
+
+static gchar *
+gimp_gegl_procedure_get_description (GimpViewable  *viewable,
+                                        gchar        **tooltip)
+{
+  GimpProcedure *procedure = GIMP_PROCEDURE (viewable);
+
+  if (tooltip)
+    *tooltip = g_strdup (gimp_procedure_get_blurb (procedure));
+
+  return g_strdup (gimp_procedure_get_label (procedure));
+}
+
+static const gchar *
+gimp_gegl_procedure_get_label (GimpProcedure *procedure)
+{
+  GimpGeglProcedure *proc = GIMP_GEGL_PROCEDURE (procedure);
+  gchar             *ellipsis;
+  gchar             *label;
+
+  if (proc->label)
+    return proc->label;
+
+  label = gimp_strip_uline (gimp_procedure_get_menu_label (procedure));
+
+  ellipsis = strstr (label, "...");
+
+  if (! ellipsis)
+    ellipsis = strstr (label, "\342\200\246" /* U+2026 HORIZONTAL ELLIPSIS */);
+
+  if (ellipsis && ellipsis == (label + strlen (label) - 3))
+    *ellipsis = '\0';
+
+  proc->label = label;
+
+  return proc->label;
+}
+
+static const gchar *
+gimp_gegl_procedure_get_menu_label (GimpProcedure *procedure)
+{
+  GimpGeglProcedure *proc = GIMP_GEGL_PROCEDURE (procedure);
+
+  if (proc->menu_label)
+    return proc->menu_label;
+
+  return GIMP_PROCEDURE_CLASS (parent_class)->get_menu_label (procedure);
+}
+
+static const gchar *
+gimp_gegl_procedure_get_help_id (GimpProcedure *procedure)
+{
+  GimpGeglProcedure *proc = GIMP_GEGL_PROCEDURE (procedure);
+
+  return proc->help_id;
+}
+
+static gboolean
+gimp_gegl_procedure_get_sensitive (GimpProcedure *procedure,
+                                   GimpObject    *object)
+{
+  GimpDrawable *drawable;
+  gboolean      sensitive = FALSE;
+
+  g_return_val_if_fail (object == NULL || GIMP_IS_DRAWABLE (object), FALSE);
+
+  drawable = GIMP_DRAWABLE (object);
+
+  if (drawable)
+    {
+      GimpItem *item;
+
+      if (GIMP_IS_LAYER_MASK (drawable))
+        item = GIMP_ITEM (gimp_layer_mask_get_layer (GIMP_LAYER_MASK (drawable)));
+      else
+        item = GIMP_ITEM (drawable);
+
+      sensitive = ! gimp_item_is_content_locked (item);
+
+      if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable)))
+        sensitive = FALSE;
+    }
+
+  return sensitive;
+}
+
+static GimpValueArray *
+gimp_gegl_procedure_execute (GimpProcedure   *procedure,
+                             Gimp            *gimp,
+                             GimpContext     *context,
+                             GimpProgress    *progress,
+                             GimpValueArray  *args,
+                             GError         **error)
+{
+  return GIMP_PROCEDURE_CLASS (parent_class)->execute (procedure, gimp,
+                                                       context, progress,
+                                                       args, error);
+}
+
+static void
+gimp_gegl_procedure_execute_async (GimpProcedure  *procedure,
+                                   Gimp           *gimp,
+                                   GimpContext    *context,
+                                   GimpProgress   *progress,
+                                   GimpValueArray *args,
+                                   GimpObject     *display)
+{
+  GimpRunMode    run_mode = g_value_get_int (gimp_value_array_index (args, 0));
+  GimpObject    *settings;
+  GimpContainer *container;
+  GimpTool      *active_tool;
+
+  settings = gimp_gegl_config_new (procedure->original_name,
+                                   gimp_viewable_get_icon_name (GIMP_VIEWABLE (procedure)),
+                                   GIMP_TYPE_SETTINGS);
+
+  container = gimp_gegl_config_get_container (G_TYPE_FROM_INSTANCE (settings));
+
+  g_object_unref (settings);
+
+  /*  the last used settings  */
+  settings = gimp_container_get_child_by_index (container, 0);
+
+  /*  only use the settings if they are automatically created "last used"
+   *  values, not if they were saved explicitly and have a zero timestamp
+   */
+  if (settings && GIMP_SETTINGS (settings)->time == 0)
+    settings = NULL;
+
+  if (run_mode == GIMP_RUN_WITH_LAST_VALS)
+    {
+      if (settings)
+        {
+          GimpImage    *image;
+          GimpDrawable *drawable;
+          GeglNode     *node;
+
+          node = gegl_node_new_child (NULL,
+                                      "operation", procedure->original_name,
+                                      NULL);
+          gimp_gegl_config_sync_node (settings, node);
+
+          image = gimp_value_get_image (gimp_value_array_index (args, 1),
+                                        gimp);
+          drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2),
+                                              gimp);
+
+          gimp_drawable_apply_operation (drawable, progress,
+                                         gimp_procedure_get_label (procedure),
+                                         node);
+          g_object_unref (node);
+
+          gimp_image_flush (image);
+          return;
+        }
+
+      gimp_message (gimp,
+                    G_OBJECT (progress), GIMP_MESSAGE_WARNING,
+                    _("There are no last settings for '%s', "
+                      "showing the filter dialog instead."),
+                    gimp_procedure_get_label (procedure));
+    }
+
+  active_tool = tool_manager_get_active (gimp);
+
+  /*  do not use the passed context because we need to set the active
+   *  tool on the global user context
+   */
+  context = gimp_get_user_context (gimp);
+
+  if (G_TYPE_FROM_INSTANCE (active_tool) != GIMP_TYPE_OPERATION_TOOL)
+    {
+      GimpToolInfo *tool_info = gimp_get_tool_info (gimp,
+                                                    "gimp-operation-tool");
+
+      if (GIMP_IS_TOOL_INFO (tool_info))
+        gimp_context_set_tool (context, tool_info);
+    }
+  else
+    {
+      gimp_context_tool_changed (context);
+    }
+
+  active_tool = tool_manager_get_active (gimp);
+
+  if (GIMP_IS_OPERATION_TOOL (active_tool))
+    {
+      gimp_operation_tool_set_operation (GIMP_OPERATION_TOOL (active_tool),
+                                         procedure->original_name,
+                                         gimp_procedure_get_label (procedure),
+                                         gimp_procedure_get_label (procedure),
+                                         gimp_procedure_get_label (procedure),
+                                         gimp_viewable_get_icon_name (GIMP_VIEWABLE (procedure)),
+                                         gimp_procedure_get_help_id (procedure));
+
+      tool_manager_initialize_active (gimp, GIMP_DISPLAY (display));
+
+      if (settings)
+        {
+          GObject *tool_config = GIMP_FILTER_TOOL (active_tool)->config;
+
+          gimp_config_copy (GIMP_CONFIG (settings),
+                            GIMP_CONFIG (tool_config), 0);
+
+          /* see comment in gimp_settings_box_setting_selected() */
+          g_object_set (tool_config, "time", 0, NULL);
+        }
+    }
+}
+
+
+/*  public functions  */
+
+GimpProcedure *
+gimp_gegl_procedure_new (Gimp        *gimp,
+                         const gchar *operation,
+                         const gchar *name,
+                         const gchar *menu_label,
+                         const gchar *tooltip,
+                         const gchar *icon_name,
+                         const gchar *help_id)
+{
+  GimpProcedure *procedure;
+
+  g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
+  g_return_val_if_fail (operation != NULL, NULL);
+  g_return_val_if_fail (name != NULL, NULL);
+  g_return_val_if_fail (menu_label != NULL, NULL);
+
+  procedure = g_object_new (GIMP_TYPE_GEGL_PROCEDURE, NULL);
+
+  GIMP_GEGL_PROCEDURE (procedure)->menu_label = g_strdup (menu_label);
+  GIMP_GEGL_PROCEDURE (procedure)->help_id    = g_strdup (help_id);
+
+  gimp_object_set_name (GIMP_OBJECT (procedure), name);
+  gimp_viewable_set_icon_name (GIMP_VIEWABLE (procedure), icon_name);
+  gimp_procedure_set_strings (procedure,
+                              operation,
+                              tooltip,
+                              tooltip,
+                              "author", "copyright", "date",
+                              NULL);
+
+  gimp_procedure_add_argument (procedure,
+                               gimp_param_spec_int32 ("dummy-param",
+                                                      "Dummy Param",
+                                                      "Dummy parameter",
+                                                      G_MININT32, G_MAXINT32, 0,
+                                                      GIMP_PARAM_READWRITE));
+  gimp_procedure_add_argument (procedure,
+                               gimp_param_spec_image_id ("image",
+                                                         "Image",
+                                                         "Input image",
+                                                         gimp, FALSE,
+                                                         GIMP_PARAM_READWRITE));
+  gimp_procedure_add_argument (procedure,
+                               gimp_param_spec_drawable_id ("drawable",
+                                                            "Drawable",
+                                                            "Input drawable",
+                                                            gimp, TRUE,
+                                                            GIMP_PARAM_READWRITE));
+
+  return procedure;
+}

app/actions/gimpgeglprocedure.h

@@ -0,0 +1,65 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * gimpgeglprocedure.h
+ * Copyright (C) 2016 Michael Natterer <mitch@gimp.org>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __GIMP_GEGL_PROCEDURE_H__
+#define __GIMP_GEGL_PROCEDURE_H__
+
+
+#include "pdb/gimpprocedure.h"
+
+
+#define GIMP_TYPE_GEGL_PROCEDURE            (gimp_gegl_procedure_get_type ())
+#define GIMP_GEGL_PROCEDURE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_GEGL_PROCEDURE, GimpGeglProcedure))
+#define GIMP_GEGL_PROCEDURE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_GEGL_PROCEDURE, GimpGeglProcedureClass))
+#define GIMP_IS_GEGL_PROCEDURE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_GEGL_PROCEDURE))
+#define GIMP_IS_GEGL_PROCEDURE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_GEGL_PROCEDURE))
+#define GIMP_GEGL_PROCEDURE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_GEGL_PROCEDURE, GimpGeglProcedureClass))
+
+
+typedef struct _GimpGeglProcedure      GimpGeglProcedure;
+typedef struct _GimpGeglProcedureClass GimpGeglProcedureClass;
+
+struct _GimpGeglProcedure
+{
+  GimpProcedure  parent_instance;
+
+  gchar         *menu_label;
+  gchar         *label;
+  gchar         *help_id;
+};
+
+struct _GimpGeglProcedureClass
+{
+  GimpProcedureClass parent_class;
+};
+
+
+GType           gimp_gegl_procedure_get_type (void) G_GNUC_CONST;
+
+GimpProcedure * gimp_gegl_procedure_new      (Gimp        *gimp,
+                                              const gchar *operation,
+                                              const gchar *name,
+                                              const gchar *menu_label,
+                                              const gchar *tooltip,
+                                              const gchar *icon_name,
+                                              const gchar *help_id);
+
+
+#endif /* __GIMP_GEGL_PROCEDURE_H__ */

app/actions/gradients-actions.c

@@ -62,7 +62,7 @@ static const GimpActionEntry gradients_actions[] =
     G_CALLBACK (data_copy_location_cmd_callback),
     GIMP_HELP_GRADIENT_COPY_LOCATION },
 
-  { "gradients-show-in-file-manager", "gtk-directory",
+  { "gradients-show-in-file-manager", GIMP_STOCK_FILE_MANAGER,
     NC_("gradients-action", "Show in _File Manager"), NULL,
     NC_("gradients-action", "Show gradient file location in the file manager"),
     G_CALLBACK (data_show_in_file_manager_cmd_callback),
@@ -91,7 +91,7 @@ static const GimpStringActionEntry gradients_edit_actions[] =
 {
   { "gradients-edit", "gtk-edit",
     NC_("gradients-action", "_Edit Gradient..."), NULL,
-    NC_("gradients-action", "Edit gradient"),
+    NC_("gradients-action", "Edit this gradient"),
     "gimp-gradient-editor",
     GIMP_HELP_GRADIENT_EDIT }
 };

app/actions/gradients-commands.c

@@ -32,6 +32,8 @@
 #include "widgets/gimpcontainerview.h"
 #include "widgets/gimphelp-ids.h"
 
+#include "dialogs/dialogs.h"
+
 #include "gradients-commands.h"
 
 #include "gimp-intl.h"
@@ -53,64 +55,69 @@ gradients_save_as_pov_ray_cmd_callback (GtkAction *action,
   GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
   GimpContext         *context;
   GimpGradient        *gradient;
-  GtkFileChooser      *chooser;
+  GtkWidget           *dialog;
-  gchar               *title;
-
-  context = gimp_container_view_get_context (editor->view);
 
+  context  = gimp_container_view_get_context (editor->view);
   gradient = gimp_context_get_gradient (context);
 
   if (! gradient)
     return;
 
-  title = g_strdup_printf (_("Save '%s' as POV-Ray"),
+#define SAVE_AS_POV_DIALOG_KEY "gimp-save-as-pov-ray-dialog"
-                           gimp_object_get_name (gradient));
 
-  chooser = GTK_FILE_CHOOSER
+  dialog = dialogs_get_dialog (G_OBJECT (gradient), SAVE_AS_POV_DIALOG_KEY);
-    (gtk_file_chooser_dialog_new (title, NULL,
-                                  GTK_FILE_CHOOSER_ACTION_SAVE,
 
-                                  GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+  if (! dialog)
-                                  GTK_STOCK_SAVE,   GTK_RESPONSE_OK,
+    {
+      gchar *title = g_strdup_printf (_("Save '%s' as POV-Ray"),
+                                      gimp_object_get_name (gradient));
 
-                                  NULL));
+      dialog = gtk_file_chooser_dialog_new (title, NULL,
+                                            GTK_FILE_CHOOSER_ACTION_SAVE,
 
-  gtk_dialog_set_alternative_button_order (GTK_DIALOG (chooser),
+                                            GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
-                                           GTK_RESPONSE_OK,
+                                            GTK_STOCK_SAVE,   GTK_RESPONSE_OK,
-                                           GTK_RESPONSE_CANCEL,
-                                           -1);
 
-  g_object_set_data (G_OBJECT (chooser), "gimp", context->gimp);
+                                            NULL);
 
-  g_free (title);
+      g_free (title);
 
-  gtk_window_set_screen (GTK_WINDOW (chooser),
+      gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
-                         gtk_widget_get_screen (GTK_WIDGET (editor)));
+      gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
+                                               GTK_RESPONSE_OK,
+                                               GTK_RESPONSE_CANCEL,
+                                               -1);
 
-  gtk_window_set_role (GTK_WINDOW (chooser), "gimp-gradient-save-pov");
+      g_object_set_data (G_OBJECT (dialog), "gimp", context->gimp);
-  gtk_window_set_position (GTK_WINDOW (chooser), GTK_WIN_POS_MOUSE);
 
-  gtk_dialog_set_default_response (GTK_DIALOG (chooser), GTK_RESPONSE_OK);
+      gtk_window_set_screen (GTK_WINDOW (dialog),
-  gtk_file_chooser_set_do_overwrite_confirmation (chooser, TRUE);
+                             gtk_widget_get_screen (GTK_WIDGET (editor)));
+      gtk_window_set_role (GTK_WINDOW (dialog), "gimp-gradient-save-pov");
+      gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
 
-  g_signal_connect (chooser, "response",
+      gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog),
-                    G_CALLBACK (gradients_save_as_pov_ray_response),
+                                                      TRUE);
-                    gradient);
-  g_signal_connect (chooser, "delete-event",
-                    G_CALLBACK (gtk_true),
-                    NULL);
 
-  g_object_ref (gradient);
+      g_signal_connect (dialog, "response",
+                        G_CALLBACK (gradients_save_as_pov_ray_response),
+                        gradient);
+      g_signal_connect (dialog, "delete-event",
+                        G_CALLBACK (gtk_true),
+                        NULL);
 
-  g_signal_connect_object (chooser, "destroy",
+      g_signal_connect_object (dialog, "destroy",
-                           G_CALLBACK (g_object_unref),
+                               G_CALLBACK (g_object_unref),
-                           gradient,
+                               g_object_ref (gradient),
-                           G_CONNECT_SWAPPED);
+                               G_CONNECT_SWAPPED);
 
-  gimp_help_connect (GTK_WIDGET (chooser), gimp_standard_help_func,
+      gimp_help_connect (dialog, gimp_standard_help_func,
-                     GIMP_HELP_GRADIENT_SAVE_AS_POV, NULL);
+                         GIMP_HELP_GRADIENT_SAVE_AS_POV, NULL);
 
-  gtk_widget_show (GTK_WIDGET (chooser));
+      dialogs_attach_dialog (G_OBJECT (gradient),
+                             SAVE_AS_POV_DIALOG_KEY, dialog);
+    }
+
+  gtk_window_present (GTK_WINDOW (dialog));
 }
 
 
@@ -123,11 +130,9 @@ gradients_save_as_pov_ray_response (GtkWidget    *dialog,
 {
   if (response_id == GTK_RESPONSE_OK)
     {
-      GFile  *file;
+      GFile  *file  = gtk_file_chooser_get_file (GTK_FILE_CHOOSER (dialog));
       GError *error = NULL;
 
-      file = gtk_file_chooser_get_file (GTK_FILE_CHOOSER (dialog));
-
       if (! gimp_gradient_save_pov (gradient, file, &error))
         {
           gimp_message_literal (g_object_get_data (G_OBJECT (dialog), "gimp"),

app/actions/image-actions.c

@@ -26,6 +26,8 @@
 
 #include "config/gimpguiconfig.h"
 
+#include "gegl/gimp-babl.h"
+
 #include "core/gimp.h"
 #include "core/gimpchannel.h"
 #include "core/gimpcontext.h"
@@ -55,9 +57,9 @@ static const GimpActionEntry image_actions[] =
 
   { "image-menu",                  NULL, NC_("image-action", "_Image")     },
   { "image-mode-menu",             NULL, NC_("image-action", "_Mode")      },
-  { "image-precision-menu",        NULL, NC_("image-action", "_Precision") },
+  { "image-precision-menu",        NULL, NC_("image-action", "Pr_ecision") },
   { "image-color-management-menu", NULL, NC_("image-action",
-                                             "_Color Management")          },
+                                             "Color Ma_nagement")          },
   { "image-transform-menu",        NULL, NC_("image-action", "_Transform") },
   { "image-guides-menu",           NULL, NC_("image-action", "_Guides")    },
 
@@ -74,6 +76,12 @@ static const GimpActionEntry image_actions[] =
     G_CALLBACK (image_new_cmd_callback),
     GIMP_HELP_FILE_NEW },
 
+  { "image-duplicate", GIMP_STOCK_DUPLICATE,
+    NC_("image-action", "_Duplicate"), "<primary>D",
+    NC_("image-action", "Create a duplicate of this image"),
+    G_CALLBACK (image_duplicate_cmd_callback),
+    GIMP_HELP_IMAGE_DUPLICATE },
+
   { "image-color-profile-assign", NULL,
     NC_("image-action", "_Assign Color Profile..."), NULL,
     NC_("image-action", "Set a color profile on the image"),
@@ -92,6 +100,12 @@ static const GimpActionEntry image_actions[] =
     G_CALLBACK (image_color_profile_discard_cmd_callback),
     GIMP_HELP_IMAGE_COLOR_PROFILE_DISCARD },
 
+  { "image-color-profile-save", NULL,
+    NC_("image-action", "_Save Color Profile to File..."), NULL,
+    NC_("image-action", "Save the image's color profile to an ICC file"),
+    G_CALLBACK (image_color_profile_save_cmd_callback),
+    GIMP_HELP_IMAGE_COLOR_PROFILE_SAVE },
+
   { "image-resize", GIMP_STOCK_RESIZE,
     NC_("image-action", "Can_vas Size..."), NULL,
     NC_("image-action", "Adjust the image dimensions"),
@@ -134,12 +148,6 @@ static const GimpActionEntry image_actions[] =
     G_CALLBACK (image_crop_to_content_cmd_callback),
     GIMP_HELP_IMAGE_CROP },
 
-  { "image-duplicate", GIMP_STOCK_DUPLICATE,
-    NC_("image-action", "_Duplicate"), "<primary>D",
-    NC_("image-action", "Create a duplicate of this image"),
-    G_CALLBACK (image_duplicate_cmd_callback),
-    GIMP_HELP_IMAGE_DUPLICATE },
-
   { "image-merge-layers", NULL,
     NC_("image-action", "Merge Visible _Layers..."), "<primary>M",
     NC_("image-action", "Merge all visible layers into one layer"),
@@ -165,6 +173,18 @@ static const GimpActionEntry image_actions[] =
     GIMP_HELP_IMAGE_PROPERTIES }
 };
 
+static const GimpToggleActionEntry image_toggle_actions[] =
+{
+  { "image-color-management-enabled", NULL,
+    NC_("image-action", "_Enable Color Management"), NULL,
+    NC_("image-action", "Whether the image is color managed. Disabling "
+        "color management is equivalent to assigning a built-in sRGB "
+        "color profile. Better leave color management enabled."),
+    G_CALLBACK (image_color_management_enabled_cmd_callback),
+    TRUE,
+    GIMP_HELP_IMAGE_COLOR_MANAGEMENT_ENABLED }
+};
+
 static const GimpRadioActionEntry image_convert_base_type_actions[] =
 {
   { "image-convert-rgb", GIMP_STOCK_CONVERT_RGB,
@@ -185,77 +205,56 @@ static const GimpRadioActionEntry image_convert_base_type_actions[] =
 
 static const GimpRadioActionEntry image_convert_precision_actions[] =
 {
-  { "image-convert-u8-linear", NULL,
+  { "image-convert-u8", NULL,
-    NC_("image-convert-action", "8 bit integer (linear)"), NULL,
+    NC_("image-convert-action", "8 bit integer"), NULL,
     NC_("image-convert-action",
-        "Convert the image to 8 bit linear integer"),
+        "Convert the image to 8 bit integer"),
-    GIMP_PRECISION_U8_LINEAR, GIMP_HELP_IMAGE_CONVERT_U8 },
+    GIMP_COMPONENT_TYPE_U8, GIMP_HELP_IMAGE_CONVERT_U8 },
 
-  { "image-convert-u8-gamma", NULL,
+  { "image-convert-u16", NULL,
-    NC_("image-convert-action", "8 bit integer (gamma)"), NULL,
+    NC_("image-convert-action", "16 bit integer"), NULL,
     NC_("image-convert-action",
-        "Convert the image to 8 bit gamma-corrected integer"),
+        "Convert the image to 16 bit integer"),
-    GIMP_PRECISION_U8_GAMMA, GIMP_HELP_IMAGE_CONVERT_U8 },
+    GIMP_COMPONENT_TYPE_U16, GIMP_HELP_IMAGE_CONVERT_U16 },
 
-  { "image-convert-u16-linear", NULL,
+  { "image-convert-u32", NULL,
-    NC_("image-convert-action", "16 bit integer (linear)"), NULL,
+    NC_("image-convert-action", "32 bit integer"), NULL,
     NC_("image-convert-action",
-        "Convert the image to 16 bit linear integer"),
+        "Convert the image to 32 bit integer"),
-    GIMP_PRECISION_U16_LINEAR, GIMP_HELP_IMAGE_CONVERT_U16 },
+    GIMP_COMPONENT_TYPE_U32, GIMP_HELP_IMAGE_CONVERT_U32 },
 
-  { "image-convert-u16-gamma", NULL,
+  { "image-convert-half", NULL,
-    NC_("image-convert-action", "16 bit integer (gamma)"), NULL,
+    NC_("image-convert-action", "16 bit floating point"), NULL,
     NC_("image-convert-action",
-        "Convert the image to 16 bit gamma-corrected integer"),
+        "Convert the image to 16 bit floating point"),
-    GIMP_PRECISION_U16_GAMMA, GIMP_HELP_IMAGE_CONVERT_U16 },
+    GIMP_COMPONENT_TYPE_HALF, GIMP_HELP_IMAGE_CONVERT_HALF },
 
-  { "image-convert-u32-linear", NULL,
+  { "image-convert-float", NULL,
-    NC_("image-convert-action", "32 bit integer (linear)"), NULL,
+    NC_("image-convert-action", "32 bit floating point"), NULL,
     NC_("image-convert-action",
-        "Convert the image to 32 bit linear integer"),
+        "Convert the image to 32 bit floating point"),
-    GIMP_PRECISION_U32_LINEAR, GIMP_HELP_IMAGE_CONVERT_U32 },
+    GIMP_COMPONENT_TYPE_FLOAT, GIMP_HELP_IMAGE_CONVERT_FLOAT },
 
-  { "image-convert-u32-gamma", NULL,
+  { "image-convert-double", NULL,
-    NC_("image-convert-action", "32 bit integer (gamma)"), NULL,
+    NC_("image-convert-action", "64 bit floating point"), NULL,
     NC_("image-convert-action",
-        "Convert the image to 32 bit gamma-corrected integer"),
+        "Convert the image to 64 bit floating point"),
-    GIMP_PRECISION_U32_GAMMA, GIMP_HELP_IMAGE_CONVERT_U32 },
+    GIMP_COMPONENT_TYPE_DOUBLE, GIMP_HELP_IMAGE_CONVERT_DOUBLE }
+};
 
-  { "image-convert-half-linear", NULL,
+static const GimpRadioActionEntry image_convert_gamma_actions[] =
-    NC_("image-convert-action", "16 bit floating point (linear)"), NULL,
+{
+  { "image-convert-gamma", NULL,
+    NC_("image-convert-action", "Perceptual gamma (sRGB)"), NULL,
     NC_("image-convert-action",
-        "Convert the image to 16 bit linear floating point"),
+        "Convert the image to preceptual (sRGB) gamma"),
-    GIMP_PRECISION_HALF_LINEAR, GIMP_HELP_IMAGE_CONVERT_HALF },
+    FALSE, GIMP_HELP_IMAGE_CONVERT_GAMMA },
 
-  { "image-convert-half-gamma", NULL,
+  { "image-convert-linear", NULL,
-    NC_("image-convert-action", "16 bit floating point (gamma)"), NULL,
+    NC_("image-convert-action", "Linear light"), NULL,
     NC_("image-convert-action",
-        "Convert the image to 16 bit gamma-corrected floating point"),
+        "Convert the image to linear light"),
-    GIMP_PRECISION_HALF_GAMMA, GIMP_HELP_IMAGE_CONVERT_HALF },
+    TRUE, GIMP_HELP_IMAGE_CONVERT_GAMMA }
-
-  { "image-convert-float-linear", NULL,
-    NC_("image-convert-action", "32 bit floating point (linear)"), NULL,
-    NC_("image-convert-action",
-        "Convert the image to 32 bit linear floating point"),
-    GIMP_PRECISION_FLOAT_LINEAR, GIMP_HELP_IMAGE_CONVERT_FLOAT },
-
-  { "image-convert-float-gamma", NULL,
-    NC_("image-convert-action", "32 bit floating point (gamma)"), NULL,
-    NC_("image-convert-action",
-        "Convert the image to 32 bit gamma-corrected floating point"),
-    GIMP_PRECISION_FLOAT_GAMMA, GIMP_HELP_IMAGE_CONVERT_FLOAT },
-
-  { "image-convert-double-linear", NULL,
-    NC_("image-convert-action", "64 bit floating point (linear)"), NULL,
-    NC_("image-convert-action",
-        "Convert the image to 64 bit linear floating point"),
-    GIMP_PRECISION_DOUBLE_LINEAR, GIMP_HELP_IMAGE_CONVERT_DOUBLE },
-
-  { "image-convert-double-gamma", NULL,
-    NC_("image-convert-action", "64 bit floating point (gamma)"), NULL,
-    NC_("image-convert-action",
-        "Convert the image to 64 bit gamma-corrected floating point"),
-    GIMP_PRECISION_DOUBLE_GAMMA, GIMP_HELP_IMAGE_CONVERT_DOUBLE }
 };
 
 static const GimpEnumActionEntry image_flip_actions[] =
@@ -302,6 +301,10 @@ image_actions_setup (GimpActionGroup *group)
                                  image_actions,
                                  G_N_ELEMENTS (image_actions));
 
+  gimp_action_group_add_toggle_actions (group, "image-action",
+                                        image_toggle_actions,
+                                        G_N_ELEMENTS (image_toggle_actions));
+
   gimp_action_group_add_radio_actions (group, "image-convert-action",
                                        image_convert_base_type_actions,
                                        G_N_ELEMENTS (image_convert_base_type_actions),
@@ -314,6 +317,12 @@ image_actions_setup (GimpActionGroup *group)
                                        NULL, 0,
                                        G_CALLBACK (image_convert_precision_cmd_callback));
 
+  gimp_action_group_add_radio_actions (group, "image-convert-action",
+                                       image_convert_gamma_actions,
+                                       G_N_ELEMENTS (image_convert_gamma_actions),
+                                       NULL, 0,
+                                       G_CALLBACK (image_convert_gamma_cmd_callback));
+
   gimp_action_group_add_enum_actions (group, "image-action",
                                       image_flip_actions,
                                       G_N_ELEMENTS (image_flip_actions),
@@ -338,21 +347,27 @@ void
 image_actions_update (GimpActionGroup *group,
                       gpointer         data)
 {
-  GimpImage *image       = action_data_get_image (data);
+  GimpImage *image         = action_data_get_image (data);
-  gboolean   is_indexed  = FALSE;
+  gboolean   is_indexed    = FALSE;
-  gboolean   is_u8_gamma = FALSE;
+  gboolean   is_u8_gamma   = FALSE;
-  gboolean   aux         = FALSE;
+  gboolean   aux           = FALSE;
-  gboolean   lp          = FALSE;
+  gboolean   lp            = FALSE;
-  gboolean   sel         = FALSE;
+  gboolean   sel           = FALSE;
-  gboolean   groups      = FALSE;
+  gboolean   groups        = FALSE;
-  gboolean   profile     = FALSE;
+  gboolean   color_managed = FALSE;
+  gboolean   profile       = FALSE;
 
   if (image)
     {
-      GimpContainer *layers;
+      GimpContainer     *layers;
-      const gchar   *action = NULL;
+      const gchar       *action = NULL;
+      GimpImageBaseType  base_type;
+      GimpPrecision      precision;
 
-      switch (gimp_image_get_base_type (image))
+      base_type = gimp_image_get_base_type (image);
+      precision = gimp_image_get_precision (image);
+
+      switch (base_type)
         {
         case GIMP_RGB:     action = "image-convert-rgb";       break;
         case GIMP_GRAY:    action = "image-convert-grayscale"; break;
@@ -361,51 +376,32 @@ image_actions_update (GimpActionGroup *group,
 
       gimp_action_group_set_action_active (group, action, TRUE);
 
-      switch (gimp_image_get_precision (image))
+      switch (gimp_image_get_component_type (image))
         {
-        case GIMP_PRECISION_U8_LINEAR:
+        case GIMP_COMPONENT_TYPE_U8:     action = "image-convert-u8";     break;
-          action = "image-convert-u8-linear";
+        case GIMP_COMPONENT_TYPE_U16:    action = "image-convert-u16";    break;
-          break;
+        case GIMP_COMPONENT_TYPE_U32:    action = "image-convert-u32";    break;
-        case GIMP_PRECISION_U8_GAMMA:
+        case GIMP_COMPONENT_TYPE_HALF:   action = "image-convert-half";   break;
-          action = "image-convert-u8-gamma";
+        case GIMP_COMPONENT_TYPE_FLOAT:  action = "image-convert-float";  break;
-          break;
+        case GIMP_COMPONENT_TYPE_DOUBLE: action = "image-convert-double"; break;
-        case GIMP_PRECISION_U16_LINEAR:
-          action = "image-convert-u16-linear";
-          break;
-        case GIMP_PRECISION_U16_GAMMA:
-          action = "image-convert-u16-gamma";
-          break;
-        case GIMP_PRECISION_U32_LINEAR:
-          action = "image-convert-u32-linear";
-          break;
-        case GIMP_PRECISION_U32_GAMMA:
-          action = "image-convert-u32-gamma";
-          break;
-        case GIMP_PRECISION_HALF_LINEAR:
-          action = "image-convert-half-linear";
-          break;
-        case GIMP_PRECISION_HALF_GAMMA:
-          action = "image-convert-half-gamma";
-          break;
-        case GIMP_PRECISION_FLOAT_LINEAR:
-          action = "image-convert-float-linear";
-          break;
-        case GIMP_PRECISION_FLOAT_GAMMA:
-          action = "image-convert-float-gamma";
-          break;
-        case GIMP_PRECISION_DOUBLE_LINEAR:
-          action = "image-convert-double-linear";
-          break;
-        case GIMP_PRECISION_DOUBLE_GAMMA:
-          action = "image-convert-double-gamma";
-          break;
         }
 
       gimp_action_group_set_action_active (group, action, TRUE);
 
-      is_indexed  = (gimp_image_get_base_type (image) == GIMP_INDEXED);
+      if (gimp_babl_format_get_linear (gimp_image_get_layer_format (image,
-      is_u8_gamma = (gimp_image_get_precision (image) ==
+                                                                    FALSE)))
-                     GIMP_PRECISION_U8_GAMMA);
+        {
+          gimp_action_group_set_action_active (group, "image-convert-linear",
+                                               TRUE);
+        }
+      else
+        {
+          gimp_action_group_set_action_active (group, "image-convert-gamma",
+                                               TRUE);
+        }
+
+      is_indexed  = (base_type == GIMP_INDEXED);
+      is_u8_gamma = (precision == GIMP_PRECISION_U8_GAMMA);
       aux         = (gimp_image_get_active_channel (image) != NULL);
       lp          = ! gimp_image_is_empty (image);
       sel         = ! gimp_channel_is_empty (gimp_image_get_mask (image));
@@ -414,32 +410,55 @@ image_actions_update (GimpActionGroup *group,
 
       groups = ! gimp_item_stack_is_flat (GIMP_ITEM_STACK (layers));
 
-      profile = (gimp_image_get_color_profile (image) != NULL);
+      color_managed = gimp_image_get_is_color_managed (image);
+      profile       = (gimp_image_get_color_profile (image) != NULL);
     }
 
+#define SET_LABEL(action,label) \
+        gimp_action_group_set_action_label (group, action, (label))
 #define SET_SENSITIVE(action,condition) \
         gimp_action_group_set_action_sensitive (group, action, (condition) != 0)
+#define SET_ACTIVE(action,condition) \
+        gimp_action_group_set_action_active (group, action, (condition) != 0)
+
+  SET_SENSITIVE ("image-duplicate", image);
+
+  if (profile)
+    {
+      SET_LABEL ("image-convert-rgb",
+                 C_("image-convert-action", "_RGB..."));
+      SET_LABEL ("image-convert-grayscale",
+                 C_("image-convert-action", "_Grayscale..."));
+    }
+  else
+    {
+      SET_LABEL ("image-convert-rgb",
+                 C_("image-convert-action", "_RGB"));
+      SET_LABEL ("image-convert-grayscale",
+                 C_("image-convert-action", "_Grayscale"));
+    }
 
   SET_SENSITIVE ("image-convert-rgb",       image);
   SET_SENSITIVE ("image-convert-grayscale", image);
   SET_SENSITIVE ("image-convert-indexed",   image && !groups && is_u8_gamma);
 
-  SET_SENSITIVE ("image-convert-u8-gamma",      image);
+  SET_SENSITIVE ("image-convert-u8",     image);
-  SET_SENSITIVE ("image-convert-u8-linear",     image && !is_indexed);
+  SET_SENSITIVE ("image-convert-u16",    image && !is_indexed);
-  SET_SENSITIVE ("image-convert-u16-gamma",     image && !is_indexed);
+  SET_SENSITIVE ("image-convert-u32",    image && !is_indexed);
-  SET_SENSITIVE ("image-convert-u16-linear",    image && !is_indexed);
+  SET_SENSITIVE ("image-convert-half",   image && !is_indexed);
-  SET_SENSITIVE ("image-convert-u32-gamma",     image && !is_indexed);
+  SET_SENSITIVE ("image-convert-float",  image && !is_indexed);
-  SET_SENSITIVE ("image-convert-u32-linear",    image && !is_indexed);
+  SET_SENSITIVE ("image-convert-double", image && !is_indexed);
-  SET_SENSITIVE ("image-convert-half-gamma",    image && !is_indexed);
+
-  SET_SENSITIVE ("image-convert-half-linear",   image && !is_indexed);
+  SET_SENSITIVE ("image-convert-gamma",  image);
-  SET_SENSITIVE ("image-convert-float-gamma",   image && !is_indexed);
+  SET_SENSITIVE ("image-convert-linear", image && !is_indexed);
-  SET_SENSITIVE ("image-convert-float-linear",  image && !is_indexed);
+
-  SET_SENSITIVE ("image-convert-double-gamma",  image && !is_indexed);
+  SET_SENSITIVE ("image-color-management-enabled", image);
-  SET_SENSITIVE ("image-convert-double-linear", image && !is_indexed);
+  SET_ACTIVE    ("image-color-management-enabled", image && color_managed);
 
   SET_SENSITIVE ("image-color-profile-assign",  image);
   SET_SENSITIVE ("image-color-profile-convert", image);
   SET_SENSITIVE ("image-color-profile-discard", image && profile);
+  SET_SENSITIVE ("image-color-profile-save",    image);
 
   SET_SENSITIVE ("image-flip-horizontal", image);
   SET_SENSITIVE ("image-flip-vertical",   image);
@@ -454,11 +473,12 @@ image_actions_update (GimpActionGroup *group,
   SET_SENSITIVE ("image-scale",               image);
   SET_SENSITIVE ("image-crop-to-selection",   image && sel);
   SET_SENSITIVE ("image-crop-to-content",     image);
-  SET_SENSITIVE ("image-duplicate",           image);
   SET_SENSITIVE ("image-merge-layers",        image && !aux && lp);
   SET_SENSITIVE ("image-flatten",             image && !aux && lp);
   SET_SENSITIVE ("image-configure-grid",      image);
   SET_SENSITIVE ("image-properties",          image);
 
+#undef SET_LABEL
 #undef SET_SENSITIVE
+#undef SET_ACTIVE
 }

app/actions/image-commands.h

@@ -19,56 +19,62 @@
 #define __IMAGE_COMMANDS_H__
 
 
-void   image_new_cmd_callback                   (GtkAction *action,
+void   image_new_cmd_callback                      (GtkAction *action,
-                                                 gpointer   data);
+                                                    gpointer   data);
+void   image_duplicate_cmd_callback                (GtkAction *action,
+                                                    gpointer   data);
 
-void   image_convert_base_type_cmd_callback     (GtkAction *action,
+void   image_convert_base_type_cmd_callback        (GtkAction *action,
-                                                 GtkAction *current,
+                                                    GtkAction *current,
-                                                 gpointer   data);
+                                                    gpointer   data);
-void   image_convert_precision_cmd_callback     (GtkAction *action,
+void   image_convert_precision_cmd_callback        (GtkAction *action,
-                                                 GtkAction *current,
+                                                    GtkAction *current,
-                                                 gpointer   data);
+                                                    gpointer   data);
+void   image_convert_gamma_cmd_callback            (GtkAction *action,
+                                                    GtkAction *current,
+                                                    gpointer   data);
 
-void   image_color_profile_assign_cmd_callback  (GtkAction *action,
+void   image_color_management_enabled_cmd_callback (GtkAction *action,
-                                                 gpointer   data);
+                                                    gpointer   data);
-void   image_color_profile_convert_cmd_callback (GtkAction *action,
+void   image_color_profile_assign_cmd_callback     (GtkAction *action,
-                                                 gpointer   data);
+                                                    gpointer   data);
-void   image_color_profile_discard_cmd_callback (GtkAction *action,
+void   image_color_profile_convert_cmd_callback    (GtkAction *action,
-                                                 gpointer   data);
+                                                    gpointer   data);
+void   image_color_profile_discard_cmd_callback    (GtkAction *action,
+                                                    gpointer   data);
+void   image_color_profile_save_cmd_callback       (GtkAction *action,
+                                                    gpointer   data);
 
-void   image_resize_cmd_callback                (GtkAction *action,
+void   image_resize_cmd_callback                   (GtkAction *action,
-                                                 gpointer   data);
+                                                    gpointer   data);
-void   image_resize_to_layers_cmd_callback      (GtkAction *action,
+void   image_resize_to_layers_cmd_callback         (GtkAction *action,
-                                                 gpointer   data);
+                                                    gpointer   data);
-void   image_resize_to_selection_cmd_callback   (GtkAction *action,
+void   image_resize_to_selection_cmd_callback      (GtkAction *action,
-                                                 gpointer   data);
+                                                    gpointer   data);
-void   image_print_size_cmd_callback            (GtkAction *action,
+void   image_print_size_cmd_callback               (GtkAction *action,
-                                                 gpointer   data);
+                                                    gpointer   data);
-void   image_scale_cmd_callback                 (GtkAction *action,
+void   image_scale_cmd_callback                    (GtkAction *action,
-                                                 gpointer   data);
+                                                    gpointer   data);
-void   image_flip_cmd_callback                  (GtkAction *action,
+void   image_flip_cmd_callback                     (GtkAction *action,
-                                                 gint       value,
+                                                    gint       value,
-                                                 gpointer   data);
+                                                    gpointer   data);
-void   image_rotate_cmd_callback                (GtkAction *action,
+void   image_rotate_cmd_callback                   (GtkAction *action,
-                                                 gint       value,
+                                                    gint       value,
-                                                 gpointer   data);
+                                                    gpointer   data);
-void   image_crop_to_selection_cmd_callback     (GtkAction *action,
+void   image_crop_to_selection_cmd_callback        (GtkAction *action,
-                                                 gpointer   data);
+                                                    gpointer   data);
-void   image_crop_to_content_cmd_callback       (GtkAction *action,
+void   image_crop_to_content_cmd_callback          (GtkAction *action,
-                                                 gpointer   data);
+                                                    gpointer   data);
 
-void   image_duplicate_cmd_callback             (GtkAction *action,
+void   image_merge_layers_cmd_callback             (GtkAction *action,
-                                                 gpointer   data);
+                                                    gpointer   data);
+void   image_flatten_image_cmd_callback            (GtkAction *action,
+                                                    gpointer   data);
 
-void   image_merge_layers_cmd_callback          (GtkAction *action,
+void   image_configure_grid_cmd_callback           (GtkAction *action,
-                                                 gpointer   data);
+                                                    gpointer   data);
-void   image_flatten_image_cmd_callback         (GtkAction *action,
+void   image_properties_cmd_callback               (GtkAction *action,
-                                                 gpointer   data);
+                                                    gpointer   data);
-
-void   image_configure_grid_cmd_callback        (GtkAction *action,
-                                                 gpointer   data);
-void   image_properties_cmd_callback            (GtkAction *action,
-                                                 gpointer   data);
 
 
 #endif /* __IMAGE_COMMANDS_H__ */

app/actions/items-actions.c

@@ -0,0 +1,142 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <gegl.h>
+#include <gtk/gtk.h>
+
+#include "libgimpwidgets/gimpwidgets.h"
+
+#include "actions-types.h"
+
+#include "core/gimp.h"
+#include "core/gimpitem.h"
+
+#include "widgets/gimpactiongroup.h"
+#include "widgets/gimpwidgets-utils.h"
+
+#include "items-actions.h"
+
+
+void
+items_actions_setup (GimpActionGroup *group,
+                     const gchar     *prefix)
+{
+  GEnumClass *enum_class;
+  GEnumValue *value;
+
+  enum_class = g_type_class_ref (GIMP_TYPE_COLOR_TAG);
+
+  for (value = enum_class->values; value->value_name; value++)
+    {
+      gchar action[32];
+
+      g_snprintf (action, sizeof (action),
+                  "%s-color-tag-%s", prefix, value->value_nick);
+
+      if (value->value == GIMP_COLOR_TAG_NONE)
+        {
+          gimp_action_group_set_action_always_show_image (group, action, TRUE);
+        }
+      else
+        {
+          GimpRGB color;
+
+          gimp_action_group_set_action_context (group, action,
+                                                gimp_get_user_context (group->gimp));
+
+          gimp_get_color_tag_color (value->value, &color);
+          gimp_action_group_set_action_color (group, action, &color, FALSE);
+        }
+    }
+
+  g_type_class_unref (enum_class);
+}
+
+void
+items_actions_update (GimpActionGroup *group,
+                      const gchar     *prefix,
+                      GimpItem        *item)
+{
+  GEnumClass *enum_class;
+  GEnumValue *value;
+  gchar       action[32];
+  gboolean    visible       = FALSE;
+  gboolean    linked        = FALSE;
+  gboolean    has_color_tag = FALSE;
+  gboolean    locked        = FALSE;
+  gboolean    can_lock      = FALSE;
+  gboolean    locked_pos    = FALSE;
+  gboolean    can_lock_pos  = FALSE;
+  GimpRGB     tag_color;
+
+  if (item)
+    {
+      visible      = gimp_item_get_visible (item);
+      linked       = gimp_item_get_linked (item);
+      locked       = gimp_item_get_lock_content (item);
+      can_lock     = gimp_item_can_lock_content (item);
+      locked_pos   = gimp_item_get_lock_position (item);
+      can_lock_pos = gimp_item_can_lock_position (item);
+
+      has_color_tag = gimp_get_color_tag_color (gimp_item_get_color_tag (item),
+                                                &tag_color);
+    }
+
+#define SET_SENSITIVE(action,condition) \
+        gimp_action_group_set_action_sensitive (group, action, (condition) != 0)
+#define SET_ACTIVE(action,condition) \
+        gimp_action_group_set_action_active (group, action, (condition) != 0)
+#define SET_COLOR(action,color) \
+        gimp_action_group_set_action_color (group, action, color, FALSE)
+
+  g_snprintf (action, sizeof (action), "%s-visible", prefix);
+  SET_SENSITIVE (action, item);
+  SET_ACTIVE    (action, visible);
+
+  g_snprintf (action, sizeof (action), "%s-linked", prefix);
+  SET_SENSITIVE (action, item);
+  SET_ACTIVE    (action, linked);
+
+  g_snprintf (action, sizeof (action), "%s-lock-content", prefix);
+  SET_SENSITIVE (action, can_lock);
+  SET_ACTIVE    (action, locked);
+
+  g_snprintf (action, sizeof (action), "%s-lock-position", prefix);
+  SET_SENSITIVE (action, can_lock_pos);
+  SET_ACTIVE    (action, locked_pos);
+
+  g_snprintf (action, sizeof (action), "%s-color-tag-menu", prefix);
+  SET_COLOR (action, has_color_tag ? &tag_color : NULL);
+
+  enum_class = g_type_class_ref (GIMP_TYPE_COLOR_TAG);
+
+  for (value = enum_class->values; value->value_name; value++)
+    {
+      g_snprintf (action, sizeof (action),
+                  "%s-color-tag-%s", prefix, value->value_nick);
+
+      SET_SENSITIVE (action, item);
+    }
+
+  g_type_class_unref (enum_class);
+
+#undef SET_SENSITIVE
+#undef SET_ACTIVE
+#undef SET_COLOR
+}

app/actions/items-actions.h

@@ -0,0 +1,29 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __ITEMS_ACTIONS_H__
+#define __ITEMS_ACTIONS_H__
+
+
+void   items_actions_setup  (GimpActionGroup *group,
+                             const gchar     *prefix);
+void   items_actions_update (GimpActionGroup *group,
+                             const gchar     *prefix,
+                             GimpItem        *item);
+
+
+#endif /* __ITEMS_ACTIONS_H__ */

app/actions/items-commands.c

@@ -0,0 +1,423 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <gegl.h>
+#include <gtk/gtk.h>
+
+#include "libgimpconfig/gimpconfig.h"
+
+#include "actions-types.h"
+
+#include "config/gimpdialogconfig.h"
+
+#include "core/gimp.h"
+#include "core/gimpcontext.h"
+#include "core/gimpimage.h"
+#include "core/gimpimage-undo.h"
+#include "core/gimpitem.h"
+#include "core/gimpitemundo.h"
+
+#include "dialogs/dialogs.h"
+#include "dialogs/fill-dialog.h"
+#include "dialogs/stroke-dialog.h"
+
+#include "actions.h"
+#include "items-commands.h"
+
+#include "gimp-intl.h"
+
+
+/*  local function prototypes  */
+
+static void   items_fill_callback   (GtkWidget         *dialog,
+                                     GimpItem          *item,
+                                     GimpDrawable      *drawable,
+                                     GimpContext       *context,
+                                     GimpFillOptions   *options,
+                                     gpointer           user_data);
+static void   items_stroke_callback (GtkWidget         *dialog,
+                                     GimpItem          *item,
+                                     GimpDrawable      *drawable,
+                                     GimpContext       *context,
+                                     GimpStrokeOptions *options,
+                                     gpointer           user_data);
+
+
+/*  public functions  */
+
+void
+items_visible_cmd_callback (GtkAction *action,
+                            GimpImage *image,
+                            GimpItem  *item)
+{
+  gboolean visible;
+
+  visible = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+
+  if (visible != gimp_item_get_visible (item))
+    {
+      GimpUndo *undo;
+      gboolean  push_undo = TRUE;
+
+      undo = gimp_image_undo_can_compress (image, GIMP_TYPE_ITEM_UNDO,
+                                           GIMP_UNDO_ITEM_VISIBILITY);
+
+      if (undo && GIMP_ITEM_UNDO (undo)->item == item)
+        push_undo = FALSE;
+
+      gimp_item_set_visible (item, visible, push_undo);
+      gimp_image_flush (image);
+    }
+}
+
+void
+items_linked_cmd_callback (GtkAction *action,
+                           GimpImage *image,
+                           GimpItem  *item)
+{
+  gboolean linked;
+
+  linked = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+
+  if (linked != gimp_item_get_linked (item))
+    {
+      GimpUndo *undo;
+      gboolean  push_undo = TRUE;
+
+      undo = gimp_image_undo_can_compress (image, GIMP_TYPE_ITEM_UNDO,
+                                           GIMP_UNDO_ITEM_LINKED);
+
+      if (undo && GIMP_ITEM_UNDO (undo)->item == item)
+        push_undo = FALSE;
+
+      gimp_item_set_linked (item, linked, push_undo);
+      gimp_image_flush (image);
+    }
+}
+
+void
+items_lock_content_cmd_callback (GtkAction *action,
+                                 GimpImage *image,
+                                 GimpItem  *item)
+{
+  gboolean locked;
+
+  locked = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+
+  if (locked != gimp_item_get_lock_content (item))
+    {
+      GimpUndo *undo;
+      gboolean  push_undo = TRUE;
+
+      undo = gimp_image_undo_can_compress (image, GIMP_TYPE_ITEM_UNDO,
+                                           GIMP_UNDO_ITEM_LINKED);
+
+      if (undo && GIMP_ITEM_UNDO (undo)->item == item)
+        push_undo = FALSE;
+
+      gimp_item_set_lock_content (item, locked, push_undo);
+      gimp_image_flush (image);
+    }
+}
+
+void
+items_lock_position_cmd_callback (GtkAction *action,
+                                  GimpImage *image,
+                                  GimpItem  *item)
+{
+  gboolean locked;
+
+  locked = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+
+  if (locked != gimp_item_get_lock_position (item))
+    {
+      GimpUndo *undo;
+      gboolean  push_undo = TRUE;
+
+      undo = gimp_image_undo_can_compress (image, GIMP_TYPE_ITEM_UNDO,
+                                           GIMP_UNDO_ITEM_LOCK_POSITION);
+
+      if (undo && GIMP_ITEM_UNDO (undo)->item == item)
+        push_undo = FALSE;
+
+
+      gimp_item_set_lock_position (item, locked, push_undo);
+      gimp_image_flush (image);
+    }
+}
+
+void
+items_color_tag_cmd_callback (GtkAction    *action,
+                              GimpImage    *image,
+                              GimpItem     *item,
+                              GimpColorTag  color_tag)
+{
+  if (color_tag != gimp_item_get_color_tag (item))
+    {
+      GimpUndo *undo;
+      gboolean  push_undo = TRUE;
+
+      undo = gimp_image_undo_can_compress (image, GIMP_TYPE_ITEM_UNDO,
+                                           GIMP_UNDO_ITEM_COLOR_TAG);
+
+      if (undo && GIMP_ITEM_UNDO (undo)->item == item)
+        push_undo = FALSE;
+
+      gimp_item_set_color_tag (item, color_tag, push_undo);
+      gimp_image_flush (image);
+    }
+}
+
+void
+items_fill_cmd_callback (GtkAction   *action,
+                         GimpImage   *image,
+                         GimpItem    *item,
+                         const gchar *dialog_key,
+                         const gchar *dialog_title,
+                         const gchar *dialog_icon_name,
+                         const gchar *dialog_help_id,
+                         gpointer     data)
+{
+  GimpDrawable *drawable;
+  GtkWidget    *dialog;
+  GtkWidget    *widget;
+  return_if_no_widget (widget, data);
+
+  drawable = gimp_image_get_active_drawable (image);
+
+  if (! drawable)
+    {
+      gimp_message_literal (image->gimp,
+                            G_OBJECT (widget), GIMP_MESSAGE_WARNING,
+                            _("There is no active layer or channel to fill."));
+      return;
+    }
+
+  dialog = dialogs_get_dialog (G_OBJECT (item), dialog_key);
+
+  if (! dialog)
+    {
+      GimpDialogConfig *config = GIMP_DIALOG_CONFIG (image->gimp->config);
+
+      dialog = fill_dialog_new (item,
+                                drawable,
+                                action_data_get_context (data),
+                                dialog_title,
+                                dialog_icon_name,
+                                dialog_help_id,
+                                widget,
+                                config->fill_options,
+                                items_fill_callback,
+                                NULL);
+
+      dialogs_attach_dialog (G_OBJECT (item), dialog_key, dialog);
+    }
+
+  gtk_window_present (GTK_WINDOW (dialog));
+}
+
+void
+items_fill_last_vals_cmd_callback (GtkAction   *action,
+                                   GimpImage   *image,
+                                   GimpItem    *item,
+                                   gpointer     data)
+{
+  GimpDrawable     *drawable;
+  GimpDialogConfig *config;
+  GtkWidget        *widget;
+  GError           *error = NULL;
+  return_if_no_widget (widget, data);
+
+  drawable = gimp_image_get_active_drawable (image);
+
+  if (! drawable)
+    {
+      gimp_message_literal (image->gimp,
+                            G_OBJECT (widget), GIMP_MESSAGE_WARNING,
+                            _("There is no active layer or channel to fill."));
+      return;
+    }
+
+  config = GIMP_DIALOG_CONFIG (image->gimp->config);
+
+  if (! gimp_item_fill (item, drawable,
+                        config->fill_options, TRUE, NULL, &error))
+    {
+      gimp_message_literal (image->gimp, G_OBJECT (widget),
+                            GIMP_MESSAGE_WARNING, error->message);
+      g_clear_error (&error);
+    }
+  else
+    {
+      gimp_image_flush (image);
+    }
+}
+
+void
+items_stroke_cmd_callback (GtkAction   *action,
+                           GimpImage   *image,
+                           GimpItem    *item,
+                           const gchar *dialog_key,
+                           const gchar *dialog_title,
+                           const gchar *dialog_icon_name,
+                           const gchar *dialog_help_id,
+                           gpointer     data)
+{
+  GimpDrawable *drawable;
+  GtkWidget    *dialog;
+  GtkWidget    *widget;
+  return_if_no_widget (widget, data);
+
+  drawable = gimp_image_get_active_drawable (image);
+
+  if (! drawable)
+    {
+      gimp_message_literal (image->gimp,
+                            G_OBJECT (widget), GIMP_MESSAGE_WARNING,
+                            _("There is no active layer or channel to stroke to."));
+      return;
+    }
+
+  dialog = dialogs_get_dialog (G_OBJECT (item), dialog_key);
+
+  if (! dialog)
+    {
+      GimpDialogConfig *config = GIMP_DIALOG_CONFIG (image->gimp->config);
+
+      dialog = stroke_dialog_new (item,
+                                  drawable,
+                                  action_data_get_context (data),
+                                  dialog_title,
+                                  dialog_icon_name,
+                                  dialog_help_id,
+                                  widget,
+                                  config->stroke_options,
+                                  items_stroke_callback,
+                                  NULL);
+
+      dialogs_attach_dialog (G_OBJECT (item), dialog_key, dialog);
+    }
+
+  gtk_window_present (GTK_WINDOW (dialog));
+}
+
+void
+items_stroke_last_vals_cmd_callback (GtkAction   *action,
+                                     GimpImage   *image,
+                                     GimpItem    *item,
+                                     gpointer     data)
+{
+  GimpDrawable     *drawable;
+  GimpDialogConfig *config;
+  GtkWidget        *widget;
+  GError           *error = NULL;
+  return_if_no_widget (widget, data);
+
+  drawable = gimp_image_get_active_drawable (image);
+
+  if (! drawable)
+    {
+      gimp_message_literal (image->gimp,
+                            G_OBJECT (widget), GIMP_MESSAGE_WARNING,
+                            _("There is no active layer or channel to stroke to."));
+      return;
+    }
+
+  config = GIMP_DIALOG_CONFIG (image->gimp->config);
+
+  if (! gimp_item_stroke (item, drawable,
+                          action_data_get_context (data),
+                          config->stroke_options, NULL,
+                          TRUE, NULL, &error))
+    {
+      gimp_message_literal (image->gimp, G_OBJECT (widget),
+                            GIMP_MESSAGE_WARNING, error->message);
+      g_clear_error (&error);
+    }
+  else
+    {
+      gimp_image_flush (image);
+    }
+}
+
+
+/*  private functions  */
+
+static void
+items_fill_callback (GtkWidget       *dialog,
+                     GimpItem        *item,
+                     GimpDrawable    *drawable,
+                     GimpContext     *context,
+                     GimpFillOptions *options,
+                     gpointer         user_data)
+{
+  GimpDialogConfig *config = GIMP_DIALOG_CONFIG (context->gimp->config);
+  GimpImage        *image  = gimp_item_get_image (item);
+  GError           *error  = NULL;
+
+  gimp_config_sync (G_OBJECT (options),
+                    G_OBJECT (config->fill_options), 0);
+
+  if (! gimp_item_fill (item, drawable, options, TRUE, NULL, &error))
+    {
+      gimp_message_literal (context->gimp,
+                            G_OBJECT (dialog),
+                            GIMP_MESSAGE_WARNING,
+                            error ? error->message : "NULL");
+
+      g_clear_error (&error);
+      return;
+    }
+
+  gimp_image_flush (image);
+
+  gtk_widget_destroy (dialog);
+}
+
+static void
+items_stroke_callback (GtkWidget         *dialog,
+                       GimpItem          *item,
+                       GimpDrawable      *drawable,
+                       GimpContext       *context,
+                       GimpStrokeOptions *options,
+                       gpointer           data)
+{
+  GimpDialogConfig *config = GIMP_DIALOG_CONFIG (context->gimp->config);
+  GimpImage        *image  = gimp_item_get_image (item);
+  GError           *error  = NULL;
+
+  gimp_config_sync (G_OBJECT (options),
+                    G_OBJECT (config->stroke_options), 0);
+
+  if (! gimp_item_stroke (item, drawable, context, options, NULL,
+                          TRUE, NULL, &error))
+    {
+      gimp_message_literal (context->gimp,
+                            G_OBJECT (dialog),
+                            GIMP_MESSAGE_WARNING,
+                            error ? error->message : "NULL");
+
+      g_clear_error (&error);
+      return;
+    }
+
+  gimp_image_flush (image);
+
+  gtk_widget_destroy (dialog);
+}

app/actions/items-commands.h

@@ -0,0 +1,68 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __ITEMS_COMMANDS_H__
+#define __ITEMS_COMMANDS_H__
+
+
+void   items_visible_cmd_callback          (GtkAction    *action,
+                                            GimpImage    *image,
+                                            GimpItem     *item);
+void   items_linked_cmd_callback           (GtkAction    *action,
+                                            GimpImage    *image,
+                                            GimpItem     *item);
+void   items_lock_content_cmd_callback     (GtkAction    *action,
+                                            GimpImage    *image,
+                                            GimpItem     *item);
+void   items_lock_position_cmd_callback    (GtkAction    *action,
+                                            GimpImage    *image,
+                                            GimpItem     *item);
+
+void   items_color_tag_cmd_callback        (GtkAction    *action,
+                                            GimpImage    *image,
+                                            GimpItem     *item,
+                                            GimpColorTag  color_tag);
+
+void   items_fill_cmd_callback             (GtkAction    *action,
+                                            GimpImage    *image,
+                                            GimpItem     *item,
+                                            const gchar  *dialog_key,
+                                            const gchar  *dialog_title,
+                                            const gchar  *dialog_icon_name,
+                                            const gchar  *dialog_help_id,
+                                            gpointer      data);
+void   items_fill_last_vals_cmd_callback   (GtkAction    *action,
+                                            GimpImage    *image,
+                                            GimpItem     *item,
+                                            gpointer      data);
+
+void   items_stroke_cmd_callback           (GtkAction    *action,
+                                            GimpImage    *image,
+                                            GimpItem     *item,
+                                            const gchar  *dialog_key,
+                                            const gchar  *dialog_title,
+                                            const gchar  *dialog_icon_name,
+                                            const gchar  *dialog_help_id,
+                                            gpointer      data);
+void   items_stroke_last_vals_cmd_callback (GtkAction    *action,
+                                            GimpImage    *image,
+                                            GimpItem     *item,
+                                            gpointer      data);
+
+
+
+#endif /* __ITEMS_COMMANDS_H__ */

app/actions/layers-actions.c

@@ -27,7 +27,7 @@
 #include "core/gimpchannel.h"
 #include "core/gimpimage.h"
 #include "core/gimplayer.h"
-#include "core/gimplayer-floating-sel.h"
+#include "core/gimplayer-floating-selection.h"
 
 #include "text/gimptextlayer.h"
 
@@ -37,6 +37,7 @@
 
 #include "actions.h"
 #include "image-commands.h"
+#include "items-actions.h"
 #include "layers-actions.h"
 #include "layers-commands.h"
 
@@ -49,6 +50,10 @@ static const GimpActionEntry layers_actions[] =
     NC_("layers-action", "Layers Menu"), NULL, NULL, NULL,
     GIMP_HELP_LAYER_DIALOG },
 
+  { "layers-color-tag-menu", GIMP_STOCK_CLOSE /* abused */,
+    NC_("layers-action", "Color Tag"), NULL, NULL, NULL,
+    GIMP_HELP_LAYER_COLOR_TAG },
+
   { "layers-menu",                   NULL,
     NC_("layers-action", "_Layer")        },
   { "layers-stack-menu",             NULL,
@@ -97,7 +102,7 @@ static const GimpActionEntry layers_actions[] =
     G_CALLBACK (layers_new_from_visible_cmd_callback),
     GIMP_HELP_LAYER_NEW_FROM_VISIBLE },
 
-  { "layers-new-group", "folder",
+  { "layers-new-group", "folder-new",
     NC_("layers-action", "New Layer _Group"), NULL,
     NC_("layers-action", "Create a new layer group and add it to the image"),
     G_CALLBACK (layers_new_group_cmd_callback),
@@ -225,6 +230,23 @@ static const GimpActionEntry layers_actions[] =
     G_CALLBACK (layers_mask_add_cmd_callback),
     GIMP_HELP_LAYER_MASK_ADD },
 
+  /* this is the same as layers-mask-add, except it's sensitive even if
+   * there is a mask on the layer
+   */
+  { "layers-mask-add-button", GIMP_STOCK_LAYER_MASK,
+    NC_("layers-action", "Add La_yer Mask..."), NULL,
+    NC_("layers-action",
+        "Add a mask that allows non-destructive editing of transparency"),
+    G_CALLBACK (layers_mask_add_cmd_callback),
+    GIMP_HELP_LAYER_MASK_ADD },
+
+  { "layers-mask-add-last-values", GIMP_STOCK_LAYER_MASK,
+    NC_("layers-action", "Add La_yer Mask"), NULL,
+    NC_("layers-action",
+        "Add a mask with last used values"),
+    G_CALLBACK (layers_mask_add_last_vals_cmd_callback),
+    GIMP_HELP_LAYER_MASK_ADD },
+
   { "layers-alpha-add", GIMP_STOCK_TRANSPARENCY,
     NC_("layers-action", "Add Alpha C_hannel"), NULL,
     NC_("layers-action", "Add transparency information to the layer"),
@@ -240,14 +262,6 @@ static const GimpActionEntry layers_actions[] =
 
 static const GimpToggleActionEntry layers_toggle_actions[] =
 {
-  { "layers-lock-alpha", GIMP_STOCK_TRANSPARENCY,
-    NC_("layers-action", "Lock Alph_a Channel"), NULL,
-    NC_("layers-action",
-        "Keep transparency information on this layer from being modified"),
-    G_CALLBACK (layers_lock_alpha_cmd_callback),
-    FALSE,
-    GIMP_HELP_LAYER_LOCK_ALPHA },
-
   { "layers-mask-edit", "gtk-edit",
     NC_("layers-action", "_Edit Layer Mask"), NULL,
     NC_("layers-action", "Work on the layer mask"),
@@ -266,7 +280,96 @@ static const GimpToggleActionEntry layers_toggle_actions[] =
     NC_("layers-action", "Dismiss the effect of the layer mask"),
     G_CALLBACK (layers_mask_disable_cmd_callback),
     FALSE,
-    GIMP_HELP_LAYER_MASK_DISABLE }
+    GIMP_HELP_LAYER_MASK_DISABLE },
+
+  { "layers-visible", GIMP_STOCK_VISIBLE,
+    NC_("layers-action", "_Visible"), NULL, NULL,
+    G_CALLBACK (layers_visible_cmd_callback),
+    FALSE,
+    GIMP_HELP_LAYER_VISIBLE },
+
+  { "layers-linked", GIMP_STOCK_LINKED,
+    NC_("layers-action", "_Linked"), NULL, NULL,
+    G_CALLBACK (layers_linked_cmd_callback),
+    FALSE,
+    GIMP_HELP_LAYER_LINKED },
+
+  { "layers-lock-content", NULL /* GIMP_STOCK_LOCK */,
+    NC_("layers-action", "L_ock pixels"), NULL, NULL,
+    G_CALLBACK (layers_lock_content_cmd_callback),
+    FALSE,
+    GIMP_HELP_LAYER_LOCK_PIXELS },
+
+  { "layers-lock-position", GIMP_STOCK_TOOL_MOVE,
+    NC_("layers-action", "L_ock position"), NULL, NULL,
+    G_CALLBACK (layers_lock_position_cmd_callback),
+    FALSE,
+    GIMP_HELP_LAYER_LOCK_POSITION },
+
+  { "layers-lock-alpha", GIMP_STOCK_TRANSPARENCY,
+    NC_("layers-action", "Lock Alph_a Channel"), NULL,
+    NC_("layers-action",
+        "Keep transparency information on this layer from being modified"),
+    G_CALLBACK (layers_lock_alpha_cmd_callback),
+    FALSE,
+    GIMP_HELP_LAYER_LOCK_ALPHA },
+};
+
+static const GimpEnumActionEntry layers_color_tag_actions[] =
+{
+  { "layers-color-tag-none", GIMP_STOCK_CLOSE /* abused */,
+    NC_("layers-action", "None"), NULL,
+    NC_("layers-action", "Clear color tag"),
+    GIMP_COLOR_TAG_NONE, FALSE,
+    GIMP_HELP_LAYER_COLOR_TAG },
+
+  { "layers-color-tag-blue", NULL,
+    NC_("layers-action", "Blue"), NULL,
+    NC_("layers-action", "Set color tag to blue"),
+    GIMP_COLOR_TAG_BLUE, FALSE,
+    GIMP_HELP_LAYER_COLOR_TAG },
+
+  { "layers-color-tag-green", NULL,
+    NC_("layers-action", "Green"), NULL,
+    NC_("layers-action", "Set color tag to green"),
+    GIMP_COLOR_TAG_GREEN, FALSE,
+    GIMP_HELP_LAYER_COLOR_TAG },
+
+  { "layers-color-tag-yellow", NULL,
+    NC_("layers-action", "Yellow"), NULL,
+    NC_("layers-action", "Set color tag to yellow"),
+    GIMP_COLOR_TAG_YELLOW, FALSE,
+    GIMP_HELP_LAYER_COLOR_TAG },
+
+  { "layers-color-tag-orange", NULL,
+    NC_("layers-action", "Orange"), NULL,
+    NC_("layers-action", "Set color tag to orange"),
+    GIMP_COLOR_TAG_ORANGE, FALSE,
+    GIMP_HELP_LAYER_COLOR_TAG },
+
+  { "layers-color-tag-brown", NULL,
+    NC_("layers-action", "Brown"), NULL,
+    NC_("layers-action", "Set color tag to brown"),
+    GIMP_COLOR_TAG_BROWN, FALSE,
+    GIMP_HELP_LAYER_COLOR_TAG },
+
+  { "layers-color-tag-red", NULL,
+    NC_("layers-action", "Red"), NULL,
+    NC_("layers-action", "Set color tag to red"),
+    GIMP_COLOR_TAG_RED, FALSE,
+    GIMP_HELP_LAYER_COLOR_TAG },
+
+  { "layers-color-tag-violet", NULL,
+    NC_("layers-action", "Violet"), NULL,
+    NC_("layers-action", "Set color tag to violet"),
+    GIMP_COLOR_TAG_VIOLET, FALSE,
+    GIMP_HELP_LAYER_COLOR_TAG },
+
+  { "layers-color-tag-gray", NULL,
+    NC_("layers-action", "Gray"), NULL,
+    NC_("layers-action", "Set color tag to gray"),
+    GIMP_COLOR_TAG_GRAY, FALSE,
+    GIMP_HELP_LAYER_COLOR_TAG }
 };
 
 static const GimpEnumActionEntry layers_mask_apply_actions[] =
@@ -479,6 +582,11 @@ layers_actions_setup (GimpActionGroup *group)
                                         layers_toggle_actions,
                                         G_N_ELEMENTS (layers_toggle_actions));
 
+  gimp_action_group_add_enum_actions (group, "layers-action",
+                                      layers_color_tag_actions,
+                                      G_N_ELEMENTS (layers_color_tag_actions),
+                                      G_CALLBACK (layers_color_tag_cmd_callback));
+
   gimp_action_group_add_enum_actions (group, "layers-action",
                                       layers_mask_apply_actions,
                                       G_N_ELEMENTS (layers_mask_apply_actions),
@@ -517,6 +625,8 @@ layers_actions_setup (GimpActionGroup *group)
                                       layers_mode_actions,
                                       G_N_ELEMENTS (layers_mode_actions),
                                       G_CALLBACK (layers_mode_cmd_callback));
+
+  items_actions_setup (group, "layers");
 }
 
 void
@@ -660,7 +770,10 @@ layers_actions_update (GimpActionGroup *group,
   SET_SENSITIVE ("layers-lock-alpha", can_lock_alpha);
   SET_ACTIVE    ("layers-lock-alpha", lock_alpha);
 
-  SET_SENSITIVE ("layers-mask-add",    layer    && !fs && !ac && !mask && !children);
+  SET_SENSITIVE ("layers-mask-add",             layer && !fs && !ac && !mask && !children);
+  SET_SENSITIVE ("layers-mask-add-button",      layer && !fs && !ac && !children);
+  SET_SENSITIVE ("layers-mask-add-last-values", layer && !fs && !ac && !mask && !children);
+
   SET_SENSITIVE ("layers-mask-apply",  writable && !fs && !ac &&  mask && !children);
   SET_SENSITIVE ("layers-mask-delete", layer    && !fs && !ac &&  mask);
 
@@ -686,4 +799,6 @@ layers_actions_update (GimpActionGroup *group,
 #undef SET_SENSITIVE
 #undef SET_ACTIVE
 #undef SET_LABEL
+
+  items_actions_update (group, "layers", GIMP_ITEM (layer));
 }

app/actions/layers-commands.h

@@ -77,6 +77,8 @@ void   layers_crop_to_content_cmd_callback    (GtkAction   *action,
 
 void   layers_mask_add_cmd_callback           (GtkAction   *action,
                                                gpointer     data);
+void   layers_mask_add_last_vals_cmd_callback (GtkAction   *action,
+                                               gpointer     data);
 void   layers_mask_apply_cmd_callback         (GtkAction   *action,
                                                gint         value,
                                                gpointer     data);
@@ -105,8 +107,20 @@ void   layers_mode_cmd_callback               (GtkAction   *action,
                                                gint         value,
                                                gpointer     data);
 
+void   layers_visible_cmd_callback            (GtkAction   *action,
+                                               gpointer     data);
+void   layers_linked_cmd_callback             (GtkAction   *action,
+                                               gpointer     data);
+void   layers_lock_content_cmd_callback       (GtkAction   *action,
+                                               gpointer     data);
+void   layers_lock_position_cmd_callback      (GtkAction   *action,
+                                               gpointer     data);
 void   layers_lock_alpha_cmd_callback         (GtkAction   *action,
                                                gpointer     data);
 
+void   layers_color_tag_cmd_callback          (GtkAction   *action,
+                                               gint         value,
+                                               gpointer     data);
+
 
 #endif /* __LAYERS_COMMANDS_H__ */

app/actions/mypaint-brushes-actions.c

@@ -0,0 +1,142 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <gegl.h>
+#include <gtk/gtk.h>
+
+#include "libgimpwidgets/gimpwidgets.h"
+
+#include "actions-types.h"
+
+#include "core/gimpcontext.h"
+#include "core/gimpmybrush.h"
+
+#include "widgets/gimpactiongroup.h"
+#include "widgets/gimphelp-ids.h"
+
+#include "actions.h"
+#include "data-commands.h"
+#include "mypaint-brushes-actions.h"
+
+#include "gimp-intl.h"
+
+
+static const GimpActionEntry mypaint_brushes_actions[] =
+{
+  { "mypaint-brushes-popup", GIMP_STOCK_MYPAINT_BRUSH,
+    NC_("mypaint-brushes-action", "MyPaint Brushes Menu"), NULL, NULL, NULL,
+    GIMP_HELP_MYPAINT_BRUSH_DIALOG },
+
+  { "mypaint-brushes-new", "document-new",
+    NC_("mypaint-brushes-action", "_New MyPaint Brush"), NULL,
+    NC_("mypaint-brushes-action", "Create a new MyPaint brush"),
+    G_CALLBACK (data_new_cmd_callback),
+    GIMP_HELP_MYPAINT_BRUSH_NEW },
+
+  { "mypaint-brushes-duplicate", GIMP_STOCK_DUPLICATE,
+    NC_("mypaint-brushes-action", "D_uplicate MyPaint Brush"), NULL,
+    NC_("mypaint-brushes-action", "Duplicate this MyPaint brush"),
+    G_CALLBACK (data_duplicate_cmd_callback),
+    GIMP_HELP_MYPAINT_BRUSH_DUPLICATE },
+
+  { "mypaint-brushes-copy-location", "edit-copy",
+    NC_("mypaint-brushes-action", "Copy MyPaint Brush _Location"), NULL,
+    NC_("mypaint-brushes-action", "Copy MyPaint brush file location to clipboard"),
+    G_CALLBACK (data_copy_location_cmd_callback),
+    GIMP_HELP_MYPAINT_BRUSH_COPY_LOCATION },
+
+  { "mypaint-brushes-show-in-file-manager", GIMP_STOCK_FILE_MANAGER,
+    NC_("mypaint-brushes-action", "Show in _File Manager"), NULL,
+    NC_("mypaint-brushes-action", "Show MyPaint brush file location in the file manager"),
+    G_CALLBACK (data_show_in_file_manager_cmd_callback),
+    GIMP_HELP_MYPAINT_BRUSH_SHOW_IN_FILE_MANAGER },
+
+  { "mypaint-brushes-delete", "edit-delete",
+    NC_("mypaint-brushes-action", "_Delete MyPaint Brush"), NULL,
+    NC_("mypaint-brushes-action", "Delete this MyPaint brush"),
+    G_CALLBACK (data_delete_cmd_callback),
+    GIMP_HELP_MYPAINT_BRUSH_DELETE },
+
+  { "mypaint-brushes-refresh", "view-refresh",
+    NC_("mypaint-brushes-action", "_Refresh MyPaint Brushes"), NULL,
+    NC_("mypaint-brushes-action", "Refresh MyPaint brushes"),
+    G_CALLBACK (data_refresh_cmd_callback),
+    GIMP_HELP_MYPAINT_BRUSH_REFRESH }
+};
+
+static const GimpStringActionEntry mypaint_brushes_edit_actions[] =
+{
+  { "mypaint-brushes-edit", "gtk-edit",
+    NC_("mypaint-brushes-action", "_Edit MyPaint Brush..."), NULL,
+    NC_("mypaint-brushes-action", "Edit MyPaint brush"),
+    "gimp-mybrush-editor",
+    GIMP_HELP_MYPAINT_BRUSH_EDIT }
+};
+
+
+void
+mypaint_brushes_actions_setup (GimpActionGroup *group)
+{
+  gimp_action_group_add_actions (group, "mypaint-brushes-action",
+                                 mypaint_brushes_actions,
+                                 G_N_ELEMENTS (mypaint_brushes_actions));
+
+  gimp_action_group_add_string_actions (group, "mypaint-brushes-action",
+                                        mypaint_brushes_edit_actions,
+                                        G_N_ELEMENTS (mypaint_brushes_edit_actions),
+                                        G_CALLBACK (data_edit_cmd_callback));
+}
+
+void
+mypaint_brushes_actions_update (GimpActionGroup *group,
+                                gpointer         user_data)
+{
+  GimpContext *context = action_data_get_context (user_data);
+  GimpMybrush *brush   = NULL;
+  GimpData    *data    = NULL;
+  GFile       *file    = NULL;
+
+  if (context)
+    {
+      brush = gimp_context_get_mybrush (context);
+
+      if (action_data_sel_count (user_data) > 1)
+        {
+          brush = NULL;
+        }
+
+      if (brush)
+        {
+          data = GIMP_DATA (brush);
+
+          file = gimp_data_get_file (data);
+        }
+    }
+
+#define SET_SENSITIVE(action,condition) \
+        gimp_action_group_set_action_sensitive (group, action, (condition) != 0)
+
+  SET_SENSITIVE ("mypaint-brushes-edit",                 brush && FALSE);
+  SET_SENSITIVE ("mypaint-brushes-duplicate",            brush && GIMP_DATA_GET_CLASS (data)->duplicate);
+  SET_SENSITIVE ("mypaint-brushes-copy-location",        file);
+  SET_SENSITIVE ("mypaint-brushes-show-in-file-manager", file);
+  SET_SENSITIVE ("mypaint-brushes-delete",               brush && gimp_data_is_deletable (data));
+
+#undef SET_SENSITIVE
+}

app/actions/mypaint-brushes-actions.h

@@ -15,14 +15,13 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef __CONVERT_TYPE_DIALOG_H__
+#ifndef __MYPAINT_BRUSHES_ACTIONS_H__
-#define __CONVERT_TYPE_DIALOG_H__
+#define __MYPAINT_BRUSHES_ACTIONS_H__
 
 
-GtkWidget * convert_type_dialog_new (GimpImage    *image,
+void   mypaint_brushes_actions_setup  (GimpActionGroup *group);
-                                     GimpContext  *context,
+void   mypaint_brushes_actions_update (GimpActionGroup *group,
-                                     GtkWidget    *parent,
+                                       gpointer         data);
-                                     GimpProgress *progress);
 
 
-#endif  /*  __CONVERT_TYPE_DIALOG_H__  */
+#endif /* __MYPAINT_BRUSHES_ACTIONS_H__ */

app/actions/palettes-actions.c

@@ -74,7 +74,7 @@ static const GimpActionEntry palettes_actions[] =
     G_CALLBACK (data_copy_location_cmd_callback),
     GIMP_HELP_PALETTE_COPY_LOCATION },
 
-  { "palettes-show-in-file-manager", "gtk-directory",
+  { "palettes-show-in-file-manager", GIMP_STOCK_FILE_MANAGER,
     NC_("palettes-action", "Show in _File Manager"), NULL,
     NC_("palettes-action", "Show palette file location in the file manager"),
     G_CALLBACK (data_show_in_file_manager_cmd_callback),
@@ -97,7 +97,7 @@ static const GimpStringActionEntry palettes_edit_actions[] =
 {
   { "palettes-edit", "gtk-edit",
     NC_("palettes-action", "_Edit Palette..."), NULL,
-    NC_("palettes-action", "Edit palette"),
+    NC_("palettes-action", "Edit this palette"),
     "gimp-palette-editor",
     GIMP_HELP_PALETTE_EDIT }
 };
@@ -120,16 +120,19 @@ void
 palettes_actions_update (GimpActionGroup *group,
                          gpointer         user_data)
 {
-  GimpContext *context = action_data_get_context (user_data);
+  GimpContext *context   = action_data_get_context (user_data);
-  GimpPalette *palette = NULL;
+  GimpPalette *palette   = NULL;
-  GimpData    *data    = NULL;
+  GimpData    *data      = NULL;
-  GFile       *file    = NULL;
+  GFile       *file      = NULL;
+  gint         sel_count = 0;
 
   if (context)
     {
       palette = gimp_context_get_palette (context);
 
-      if (action_data_sel_count (user_data) > 1)
+      sel_count = action_data_sel_count (user_data);
+
+      if (sel_count > 1)
         {
           palette = NULL;
         }
@@ -147,7 +150,7 @@ palettes_actions_update (GimpActionGroup *group,
 
   SET_SENSITIVE ("palettes-edit",                 palette);
   SET_SENSITIVE ("palettes-duplicate",            palette && GIMP_DATA_GET_CLASS (data)->duplicate);
-  SET_SENSITIVE ("palettes-merge",                FALSE); /* FIXME palette && GIMP_IS_CONTAINER_LIST_VIEW (editor->view)); */
+  SET_SENSITIVE ("palettes-merge",                sel_count > 1);
   SET_SENSITIVE ("palettes-copy-location",        file);
   SET_SENSITIVE ("palettes-show-in-file-manager", file);
   SET_SENSITIVE ("palettes-delete",               palette && gimp_data_is_deletable (data));

app/actions/palettes-commands.c

@@ -24,11 +24,11 @@
 
 #include "actions-types.h"
 
-#include "core/gimppalette.h"
+#include "core/gimp.h"
-#include "core/gimpcontainer.h"
 #include "core/gimpcontext.h"
+#include "core/gimpdatafactory.h"
+#include "core/gimppalette.h"
 
-#include "widgets/gimpcontainertreeview.h"
 #include "widgets/gimpcontainerview.h"
 #include "widgets/gimpdatafactoryview.h"
 #include "widgets/gimpdialogfactory.h"
@@ -36,6 +36,8 @@
 #include "widgets/gimpview.h"
 #include "widgets/gimpwidgets-utils.h"
 
+#include "dialogs/dialogs.h"
+
 #include "actions.h"
 #include "palettes-commands.h"
 
@@ -72,16 +74,25 @@ palettes_merge_cmd_callback (GtkAction *action,
   GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
   GtkWidget           *dialog;
 
-  dialog = gimp_query_string_box (_("Merge Palette"),
+#define MERGE_DIALOG_KEY "gimp-palettes-merge-dialog"
-                                  GTK_WIDGET (editor),
+
-                                  gimp_standard_help_func,
+  dialog = dialogs_get_dialog (G_OBJECT (editor), MERGE_DIALOG_KEY);
-                                  GIMP_HELP_PALETTE_MERGE,
+
-                                  _("Enter a name for the merged palette"),
+  if (! dialog)
-                                  NULL,
+    {
-                                  G_OBJECT (editor), "destroy",
+      dialog = gimp_query_string_box (_("Merge Palettes"),
-                                  palettes_merge_callback,
+                                      GTK_WIDGET (editor),
-                                  editor);
+                                      gimp_standard_help_func,
-  gtk_widget_show (dialog);
+                                      GIMP_HELP_PALETTE_MERGE,
+                                      _("Enter a name for the merged palette"),
+                                      NULL,
+                                      G_OBJECT (editor), "destroy",
+                                      palettes_merge_callback, editor);
+
+      dialogs_attach_dialog (G_OBJECT (editor), MERGE_DIALOG_KEY, dialog);
+    }
+
+  gtk_window_present (GTK_WINDOW (dialog));
 }
 
 
@@ -92,56 +103,48 @@ palettes_merge_callback (GtkWidget   *widget,
                          const gchar *palette_name,
                          gpointer     data)
 {
-  /* FIXME: reimplement palettes_merge_callback() */
+  GimpContainerEditor *editor = data;
-#if 0
+  GimpDataFactoryView *view   = data;
-  GimpContainerEditor *editor;
+  GimpDataFactory     *factory;
-  GimpPalette         *palette;
+  GimpContext         *context;
   GimpPalette         *new_palette;
-  GList               *sel_list;
+  GList               *selected = NULL;
+  GList               *list;
 
-  editor = (GimpContainerEditor *) data;
+  context = gimp_container_view_get_context (editor->view);
+  factory = gimp_data_factory_view_get_data_factory (view);
 
-  sel_list = GTK_LIST (GIMP_CONTAINER_LIST_VIEW (editor->view)->gtk_list)->selection;
+  gimp_container_view_get_selected (editor->view, &selected);
 
-  if (! sel_list)
+  if (g_list_length (selected) < 2)
     {
-      gimp_message_literal (gimp,
+      gimp_message_literal (context->gimp,
-                            G_OBJECT (widget), GIMP_MESSAGE_WARNING,
+                            G_OBJECT (editor), GIMP_MESSAGE_WARNING,
-                            "Can't merge palettes because "
+                            _("There must be at least two palettes selected "
-                            "there are no palettes selected.");
+                              "to merge."));
+      g_list_free (selected);
       return;
     }
 
-  new_palette = GIMP_PALETTE (gimp_palette_new (palette_name, FALSE));
+  new_palette = GIMP_PALETTE (gimp_data_factory_data_new (factory, context,
+                                                          palette_name));
 
-  while (sel_list)
+  for (list = selected; list; list = g_list_next (list))
     {
-      GimpListItem *list_item;
+      GimpPalette *palette = list->data;
+      GList       *cols;
 
-      list_item = GIMP_LIST_ITEM (sel_list->data);
+      for (cols = gimp_palette_get_colors (palette);
-
+           cols;
-      palette = (GimpPalette *) GIMP_VIEW (list_item->preview)->viewable;
+           cols = g_list_next (cols))
-
-      if (palette)
         {
-          GList *cols;
+          GimpPaletteEntry *entry = cols->data;
 
-          for (cols = gimp_palette_get_colors (palette);
+          gimp_palette_add_entry (new_palette, -1,
-               cols;
+                                  entry->name,
-               cols = g_list_next (cols))
+                                  &entry->color);
-            {
-              GimpPaletteEntry *entry = cols->data;
-
-              gimp_palette_add_entry (new_palette,
-                                      entry->name,
-                                      &entry->color);
-            }
         }
-
-      sel_list = sel_list->next;
     }
 
-  gimp_container_add (editor->view->container,
+  g_list_free (selected);
-                      GIMP_OBJECT (new_palette));
-#endif
 }

app/actions/patterns-actions.c

@@ -67,7 +67,7 @@ static const GimpActionEntry patterns_actions[] =
     G_CALLBACK (data_copy_location_cmd_callback),
     GIMP_HELP_PATTERN_COPY_LOCATION },
 
-  { "patterns-show-in-file-manager", "gtk-directory",
+  { "patterns-show-in-file-manager", GIMP_STOCK_FILE_MANAGER,
     NC_("patterns-action", "Show in _File Manager"), NULL,
     NC_("patterns-action", "Show pattern file location in the file manager"),
     G_CALLBACK (data_show_in_file_manager_cmd_callback),

app/actions/plug-in-actions.c

@@ -34,7 +34,6 @@
 
 #include "plug-in/gimppluginmanager.h"
 #include "plug-in/gimppluginmanager-help-domain.h"
-#include "plug-in/gimppluginmanager-history.h"
 #include "plug-in/gimppluginmanager-locale-domain.h"
 #include "plug-in/gimppluginmanager-menu-branch.h"
 #include "plug-in/gimppluginprocedure.h"
@@ -68,8 +67,6 @@ static void     plug_in_actions_menu_path_added      (GimpPlugInProcedure *proc,
 static void     plug_in_actions_add_proc             (GimpActionGroup     *group,
                                                       GimpPlugInProcedure *proc);
 
-static void     plug_in_actions_history_changed      (GimpPlugInManager   *manager,
-                                                      GimpActionGroup     *group);
 static gboolean plug_in_actions_check_translation    (const gchar         *original,
                                                       const gchar         *translated);
 static void     plug_in_actions_build_path           (GimpActionGroup     *group,
@@ -81,49 +78,6 @@ static void     plug_in_actions_build_path           (GimpActionGroup     *group
 
 static const GimpActionEntry plug_in_actions[] =
 {
-  { "plug-in-menu",                NULL, NC_("plug-in-action",
-                                             "Filte_rs")          },
-  { "plug-in-recent-menu",         NULL, NC_("plug-in-action",
-                                             "Recently Used")     },
-  { "plug-in-blur-menu",           NULL, NC_("plug-in-action",
-                                             "_Blur")             },
-  { "plug-in-noise-menu",          NULL, NC_("plug-in-action",
-                                             "_Noise")            },
-  { "plug-in-edge-detect-menu",    NULL, NC_("plug-in-action",
-                                             "Edge-De_tect")      },
-  { "plug-in-enhance-menu",        NULL, NC_("plug-in-action",
-                                             "En_hance")          },
-  { "plug-in-combine-menu",        NULL, NC_("plug-in-action",
-                                             "C_ombine")          },
-  { "plug-in-generic-menu",        NULL, NC_("plug-in-action",
-                                             "_Generic")          },
-  { "plug-in-light-shadow-menu",   NULL, NC_("plug-in-action",
-                                             "_Light and Shadow") },
-  { "plug-in-distorts-menu",       NULL, NC_("plug-in-action",
-                                             "_Distorts")         },
-  { "plug-in-artistic-menu",       NULL, NC_("plug-in-action",
-                                             "_Artistic")         },
-  { "plug-in-decor-menu",          NULL, NC_("plug-in-action",
-                                             "_Decor")            },
-  { "plug-in-map-menu",            NULL, NC_("plug-in-action",
-                                             "_Map")              },
-  { "plug-in-render-menu",         NULL, NC_("plug-in-action",
-                                             "_Render")           },
-  { "plug-in-render-clouds-menu",  NULL, NC_("plug-in-action",
-                                             "_Clouds")           },
-  { "plug-in-render-fractals-menu", NULL, NC_("plug-in-action",
-                                             "_Fractals")         },
-  { "plug-in-render-nature-menu",  NULL, NC_("plug-in-action",
-                                             "_Nature")           },
-  { "plug-in-render-noise-menu",   NULL, NC_("plug-in-action",
-                                             "N_oise")            },
-  { "plug-in-render-pattern-menu", NULL, NC_("plug-in-action",
-                                             "_Pattern")          },
-  { "plug-in-web-menu",            NULL, NC_("plug-in-action",
-                                             "_Web")              },
-  { "plug-in-animation-menu",      NULL, NC_("plug-in-action",
-                                             "An_imation")        },
-
   { "plug-in-reset-all", GIMP_STOCK_RESET,
     NC_("plug-in-action", "Reset all _Filters"), NULL,
     NC_("plug-in-action", "Reset all plug-ins to their default settings"),
@@ -131,43 +85,19 @@ static const GimpActionEntry plug_in_actions[] =
     GIMP_HELP_FILTER_RESET_ALL }
 };
 
-static const GimpEnumActionEntry plug_in_repeat_actions[] =
-{
-  { "plug-in-repeat", "system-run",
-    NC_("plug-in-action", "Re_peat Last"), "<primary>F",
-    NC_("plug-in-action",
-        "Rerun the last used plug-in using the same settings"),
-    GIMP_RUN_WITH_LAST_VALS, FALSE,
-    GIMP_HELP_FILTER_REPEAT },
-
-  { "plug-in-reshow", GIMP_STOCK_RESHOW_FILTER,
-    NC_("plug-in-action", "R_e-Show Last"), "<primary><shift>F",
-    NC_("plug-in-action", "Show the last used plug-in dialog again"),
-    GIMP_RUN_INTERACTIVE, FALSE,
-    GIMP_HELP_FILTER_RESHOW }
-};
-
 
 /*  public functions  */
 
 void
 plug_in_actions_setup (GimpActionGroup *group)
 {
-  GimpPlugInManager     *manager = group->gimp->plug_in_manager;
+  GimpPlugInManager *manager = group->gimp->plug_in_manager;
-  GimpPlugInActionEntry *entries;
+  GSList            *list;
-  GSList                *list;
-  gint                   n_entries;
-  gint                   i;
 
   gimp_action_group_add_actions (group, "plug-in-action",
                                  plug_in_actions,
                                  G_N_ELEMENTS (plug_in_actions));
 
-  gimp_action_group_add_enum_actions (group, "plug-in-action",
-                                      plug_in_repeat_actions,
-                                      G_N_ELEMENTS (plug_in_repeat_actions),
-                                      G_CALLBACK (plug_in_repeat_cmd_callback));
-
   for (list = gimp_plug_in_manager_get_menu_branches (manager);
        list;
        list = g_slist_next (list))
@@ -204,38 +134,6 @@ plug_in_actions_setup (GimpActionGroup *group)
   g_signal_connect_object (group->gimp->pdb, "unregister-procedure",
                            G_CALLBACK (plug_in_actions_unregister_procedure),
                            group, 0);
-
-  n_entries = gimp_plug_in_manager_history_size (manager);
-
-  entries = g_new0 (GimpPlugInActionEntry, n_entries);
-
-  for (i = 0; i < n_entries; i++)
-    {
-      entries[i].name        = g_strdup_printf ("plug-in-recent-%02d", i + 1);
-      entries[i].icon_name   = NULL;
-      entries[i].label       = "";
-      entries[i].accelerator = "";
-      entries[i].tooltip     = NULL;
-      entries[i].procedure   = NULL;
-      entries[i].help_id     = GIMP_HELP_FILTER_RESHOW;
-    }
-
-  gimp_action_group_add_plug_in_actions (group, entries, n_entries,
-                                         G_CALLBACK (plug_in_history_cmd_callback));
-
-  for (i = 0; i < n_entries; i++)
-    {
-      gimp_action_group_set_action_visible (group, entries[i].name, FALSE);
-      g_free ((gchar *) entries[i].name);
-    }
-
-  g_free (entries);
-
-  g_signal_connect_object (manager, "history-changed",
-                           G_CALLBACK (plug_in_actions_history_changed),
-                           group, 0);
-
-  plug_in_actions_history_changed (manager, group);
 }
 
 void
@@ -246,7 +144,6 @@ plug_in_actions_update (GimpActionGroup *group,
   GimpPlugInManager *manager  = group->gimp->plug_in_manager;
   GimpDrawable      *drawable = NULL;
   GSList            *list;
-  gint               i;
 
   if (image)
     drawable = gimp_image_get_active_drawable (image);
@@ -259,40 +156,15 @@ plug_in_actions_update (GimpActionGroup *group,
           ! proc->file_proc                      &&
           proc->image_types_val)
         {
-          gboolean sensitive = gimp_plug_in_procedure_get_sensitive (proc,
+          gboolean sensitive =
-                                                                     drawable);
+            gimp_procedure_get_sensitive (GIMP_PROCEDURE (proc),
+                                          GIMP_OBJECT (drawable));
 
           gimp_action_group_set_action_sensitive (group,
                                                   gimp_object_get_name (proc),
                                                   sensitive);
         }
     }
-
-  if (manager->history &&
-      gimp_plug_in_procedure_get_sensitive (manager->history->data, drawable))
-    {
-      gimp_action_group_set_action_sensitive (group, "plug-in-repeat", TRUE);
-      gimp_action_group_set_action_sensitive (group, "plug-in-reshow", TRUE);
-    }
-  else
-    {
-      gimp_action_group_set_action_sensitive (group, "plug-in-repeat", FALSE);
-      gimp_action_group_set_action_sensitive (group, "plug-in-reshow", FALSE);
-    }
-
-  for (list = manager->history, i = 0; list; list = list->next, i++)
-    {
-      GimpPlugInProcedure *proc = list->data;
-      gchar               *name = g_strdup_printf ("plug-in-recent-%02d",
-                                                   i + 1);
-      gboolean             sensitive;
-
-      sensitive = gimp_plug_in_procedure_get_sensitive (proc, drawable);
-
-      gimp_action_group_set_action_sensitive (group, name, sensitive);
-
-      g_free (name);
-    }
 }
 
 
@@ -413,19 +285,14 @@ static void
 plug_in_actions_add_proc (GimpActionGroup     *group,
                           GimpPlugInProcedure *proc)
 {
-  GimpPlugInActionEntry  entry;
+  GimpProcedureActionEntry  entry;
-  const gchar           *locale_domain;
+  const gchar              *locale_domain;
-  const gchar           *label;
+  gchar                    *path_original    = NULL;
-  gchar                 *path_original    = NULL;
+  gchar                    *path_translated  = NULL;
-  gchar                 *path_translated  = NULL;
 
   locale_domain = gimp_plug_in_procedure_get_locale_domain (proc);
 
-  if (proc->menu_label)
+  if (! proc->menu_label)
-    {
-      label = dgettext (locale_domain, proc->menu_label);
-    }
-  else
     {
       gchar *p1, *p2;
 
@@ -446,8 +313,6 @@ plug_in_actions_add_proc (GimpActionGroup     *group,
         {
           *p1 = '\0';
           *p2 = '\0';
-
-          label = p2 + 1;
         }
       else
         {
@@ -462,22 +327,15 @@ plug_in_actions_add_proc (GimpActionGroup     *group,
     }
 
   entry.name        = gimp_object_get_name (proc);
-  entry.icon_name   = gimp_plug_in_procedure_get_icon_name (proc);
+  entry.icon_name   = gimp_viewable_get_icon_name (GIMP_VIEWABLE (proc));
-  entry.label       = label;
+  entry.label       = gimp_procedure_get_menu_label (GIMP_PROCEDURE (proc));
   entry.accelerator = NULL;
-  entry.tooltip     = gimp_plug_in_procedure_get_blurb (proc);
+  entry.tooltip     = gimp_procedure_get_blurb (GIMP_PROCEDURE (proc));
-  entry.procedure   = proc;
+  entry.procedure   = GIMP_PROCEDURE (proc);
-  entry.help_id     = gimp_plug_in_procedure_get_help_id (proc);
+  entry.help_id     = gimp_procedure_get_help_id (GIMP_PROCEDURE (proc));
 
-#if 0
+  gimp_action_group_add_procedure_actions (group, &entry, 1,
-  g_print ("adding plug-in action '%s' (%s)\n",
+                                           G_CALLBACK (plug_in_run_cmd_callback));
-           gimp_object_get_name (proc), label);
-#endif
-
-  gimp_action_group_add_plug_in_actions (group, &entry, 1,
-                                         G_CALLBACK (plug_in_run_cmd_callback));
-
-  g_free ((gchar *) entry.help_id);
 
   if (proc->menu_label)
     {
@@ -514,7 +372,8 @@ plug_in_actions_add_proc (GimpActionGroup     *group,
       if (image)
         drawable = gimp_image_get_active_drawable (image);
 
-      sensitive = gimp_plug_in_procedure_get_sensitive (proc, drawable);
+      sensitive = gimp_procedure_get_sensitive (GIMP_PROCEDURE (proc),
+                                                GIMP_OBJECT (drawable));
 
       gimp_action_group_set_action_sensitive (group,
                                               gimp_object_get_name (proc),
@@ -522,115 +381,6 @@ plug_in_actions_add_proc (GimpActionGroup     *group,
     }
 }
 
-static void
-plug_in_actions_history_changed (GimpPlugInManager *manager,
-                                 GimpActionGroup   *group)
-{
-  GimpPlugInProcedure *proc;
-  gint                 i;
-
-  proc = gimp_plug_in_manager_history_nth (manager, 0);
-
-  if (proc)
-    {
-      GtkAction   *actual_action;
-      const gchar *label;
-      gchar       *repeat;
-      gchar       *reshow;
-      gboolean     sensitive = FALSE;
-
-      label = gimp_plug_in_procedure_get_label (proc);
-
-      /*  copy the sensitivity of the plug-in procedure's actual action
-       *  instead of calling plug_in_actions_update() because doing the
-       *  latter would set the sensitivity of this image's action on
-       *  all images' actions. See bug #517683.
-       */
-      actual_action = gtk_action_group_get_action (GTK_ACTION_GROUP (group),
-                                                   gimp_object_get_name (proc));
-      if (actual_action)
-        sensitive = gtk_action_get_sensitive (actual_action);
-
-      repeat = g_strdup_printf (_("Re_peat \"%s\""),  label);
-      reshow = g_strdup_printf (_("R_e-Show \"%s\""), label);
-
-      gimp_action_group_set_action_label (group, "plug-in-repeat", repeat);
-      gimp_action_group_set_action_label (group, "plug-in-reshow", reshow);
-
-      gimp_action_group_set_action_sensitive (group,
-                                              "plug-in-repeat", sensitive);
-      gimp_action_group_set_action_sensitive (group,
-                                              "plug-in-reshow", sensitive);
-
-      g_free (repeat);
-      g_free (reshow);
-    }
-  else
-    {
-      gimp_action_group_set_action_label (group, "plug-in-repeat",
-                                          _("Repeat Last"));
-      gimp_action_group_set_action_label (group, "plug-in-reshow",
-                                          _("Re-Show Last"));
-
-      gimp_action_group_set_action_sensitive (group, "plug-in-repeat", FALSE);
-      gimp_action_group_set_action_sensitive (group, "plug-in-reshow", FALSE);
-    }
-
-  for (i = 0; i < gimp_plug_in_manager_history_length (manager); i++)
-    {
-      GtkAction   *action;
-      GtkAction   *actual_action;
-      const gchar *label;
-      gchar       *name;
-      gboolean     sensitive = FALSE;
-
-      name = g_strdup_printf ("plug-in-recent-%02d", i + 1);
-      action = gtk_action_group_get_action (GTK_ACTION_GROUP (group), name);
-      g_free (name);
-
-      proc = gimp_plug_in_manager_history_nth (manager, i);
-
-      if (proc->menu_label)
-        {
-          label = dgettext (gimp_plug_in_procedure_get_locale_domain (proc),
-                            proc->menu_label);
-        }
-      else
-        {
-          label = gimp_plug_in_procedure_get_label (proc);
-        }
-
-      /*  see comment above  */
-      actual_action = gtk_action_group_get_action (GTK_ACTION_GROUP (group),
-                                                   gimp_object_get_name (proc));
-      if (actual_action)
-        sensitive = gtk_action_get_sensitive (actual_action);
-
-      g_object_set (action,
-                    "visible",   TRUE,
-                    "sensitive", sensitive,
-                    "procedure", proc,
-                    "label",     label,
-                    "icon-name", gimp_plug_in_procedure_get_icon_name (proc),
-                    "tooltip",   gimp_plug_in_procedure_get_blurb (proc),
-                    NULL);
-    }
-
-  for (; i < gimp_plug_in_manager_history_size (manager); i++)
-    {
-      GtkAction *action;
-      gchar     *name = g_strdup_printf ("plug-in-recent-%02d", i + 1);
-
-      action = gtk_action_group_get_action (GTK_ACTION_GROUP (group), name);
-      g_free (name);
-
-      g_object_set (action,
-                    "visible",   FALSE,
-                    "procedure", NULL,
-                    NULL);
-    }
-}
-
 static gboolean
 plug_in_actions_check_translation (const gchar *original,
                                    const gchar *translated)

app/actions/plug-in-commands.c

@@ -17,8 +17,6 @@
 
 #include "config.h"
 
-#include <string.h>
-
 #include <gegl.h>
 #include <gtk/gtk.h>
 
@@ -28,20 +26,18 @@
 #include "actions-types.h"
 
 #include "core/gimp.h"
-#include "core/gimp-utils.h"
+#include "core/gimp-filter-history.h"
 #include "core/gimpcontainer.h"
 #include "core/gimpcontext.h"
-#include "core/gimpdrawable.h"
 #include "core/gimpimage.h"
 #include "core/gimpitem.h"
 #include "core/gimpparamspecs.h"
 #include "core/gimpprogress.h"
 
+#include "pdb/gimpprocedure.h"
+
 #include "plug-in/gimppluginmanager.h"
 #include "plug-in/gimppluginmanager-data.h"
-#include "plug-in/gimppluginmanager-history.h"
-
-#include "pdb/gimpprocedure.h"
 
 #include "widgets/gimpbufferview.h"
 #include "widgets/gimpcontainerview.h"
@@ -53,72 +49,38 @@
 #include "widgets/gimpmessagebox.h"
 #include "widgets/gimpmessagedialog.h"
 
-#include "display/gimpdisplay.h"
+#include "dialogs/dialogs.h"
 
 #include "actions.h"
 #include "plug-in-commands.h"
+#include "procedure-commands.h"
 
 #include "gimp-intl.h"
 
 
 /*  local function prototypes  */
 
-static void  plug_in_procedure_execute     (GimpPlugInProcedure *procedure,
+static void   plug_in_reset_all_response (GtkWidget *dialog,
-                                            Gimp                *gimp,
+                                          gint       response_id,
-                                            GimpDisplay         *display,
+                                          Gimp      *gimp);
-                                            GimpValueArray      *args,
-                                            gint                 n_args);
-
-static gint  plug_in_collect_data_args     (GtkAction       *action,
-                                            GimpObject      *object,
-                                            GParamSpec     **pspecs,
-                                            GimpValueArray  *args,
-                                            gint             n_args);
-static gint  plug_in_collect_image_args    (GtkAction       *action,
-                                            GimpImage       *image,
-                                            GParamSpec     **pspecs,
-                                            GimpValueArray  *args,
-                                            gint             n_args);
-static gint  plug_in_collect_item_args     (GtkAction       *action,
-                                            GimpImage       *image,
-                                            GimpItem        *item,
-                                            GParamSpec     **pspecs,
-                                            GimpValueArray  *args,
-                                            gint             n_args);
-static gint  plug_in_collect_display_args  (GtkAction       *action,
-                                            GimpDisplay     *display,
-                                            GParamSpec     **pspecs,
-                                            GimpValueArray  *args,
-                                            gint             n_args);
-static void  plug_in_reset_all_response    (GtkWidget       *dialog,
-                                            gint             response_id,
-                                            Gimp            *gimp);
 
 
 /*  public functions  */
 
 void
-plug_in_run_cmd_callback (GtkAction           *action,
+plug_in_run_cmd_callback (GtkAction     *action,
-                          GimpPlugInProcedure *proc,
+                          GimpProcedure *procedure,
-                          gpointer             data)
+                          gpointer       data)
 {
-  GimpProcedure  *procedure = GIMP_PROCEDURE (proc);
   Gimp           *gimp;
-  GimpValueArray *args;
+  GimpValueArray *args    = NULL;
-  gint            n_args    = 0;
+  GimpDisplay    *display = NULL;
-  GimpDisplay    *display   = NULL;
   return_if_no_gimp (gimp, data);
 
-  args = gimp_procedure_get_arguments (procedure);
-
-  /* initialize the first argument  */
-  g_value_set_int (gimp_value_array_index (args, n_args),
-                   GIMP_RUN_INTERACTIVE);
-  n_args++;
-
   switch (procedure->proc_type)
     {
     case GIMP_EXTENSION:
+      args = procedure_commands_get_run_mode_arg (procedure);
       break;
 
     case GIMP_PLUGIN:
@@ -138,9 +100,7 @@ plug_in_run_cmd_callback (GtkAction           *action,
           object = gimp_context_get_by_type (context,
                                              gimp_container_get_children_type (container));
 
-          n_args = plug_in_collect_data_args (action, object,
+          args = procedure_commands_get_data_args (procedure, object);
-                                              procedure->args,
-                                              args, n_args);
         }
       else if (GIMP_IS_IMAGE_EDITOR (data))
         {
@@ -149,9 +109,7 @@ plug_in_run_cmd_callback (GtkAction           *action,
 
           image = gimp_image_editor_get_image (editor);
 
-          n_args = plug_in_collect_image_args (action, image,
+          args = procedure_commands_get_image_args (procedure, image);
-                                               procedure->args,
-                                               args, n_args);
         }
       else if (GIMP_IS_ITEM_TREE_VIEW (data))
         {
@@ -166,93 +124,40 @@ plug_in_run_cmd_callback (GtkAction           *action,
           else
             item = NULL;
 
-          n_args = plug_in_collect_item_args (action, image, item,
+          args = procedure_commands_get_item_args (procedure, image, item);
-                                              procedure->args,
-                                              args, n_args);
         }
       else
         {
           display = action_data_get_display (data);
 
-          n_args = plug_in_collect_display_args (action,
+          args = procedure_commands_get_display_args (procedure, display);
-                                                 display,
-                                                 procedure->args,
-                                                 args, n_args);
         }
       break;
 
     case GIMP_INTERNAL:
       g_warning ("Unhandled procedure type.");
-      n_args = -1;
       break;
     }
 
-  if (n_args >= 1)
+  if (args)
-    plug_in_procedure_execute (proc, gimp, display, args, n_args);
-
-  gimp_value_array_unref (args);
-}
-
-void
-plug_in_repeat_cmd_callback (GtkAction *action,
-                             gint       value,
-                             gpointer   data)
-{
-  GimpPlugInProcedure *procedure;
-  Gimp                *gimp;
-  GimpDisplay         *display;
-  GimpRunMode          run_mode;
-  return_if_no_gimp (gimp, data);
-  return_if_no_display (display, data);
-
-  run_mode = (GimpRunMode) value;
-
-  procedure = gimp_plug_in_manager_history_nth (gimp->plug_in_manager, 0);
-
-  if (procedure)
     {
-      GimpValueArray *args;
+      if (procedure_commands_run_procedure (procedure, gimp,
-      gint            n_args;
+                                            GIMP_PROGRESS (display),
-
+                                            GIMP_RUN_INTERACTIVE, args,
-      args = gimp_procedure_get_arguments (GIMP_PROCEDURE (procedure));
+                                            display))
-
+        {
-      g_value_set_int (gimp_value_array_index (args, 0), run_mode);
+          /* remember only image plug-ins */
-
+          if (procedure->num_args >= 2 &&
-      n_args = plug_in_collect_display_args (action, display,
+              GIMP_IS_PARAM_SPEC_IMAGE_ID (procedure->args[1]))
-                                             GIMP_PROCEDURE (procedure)->args,
+            {
-                                             args, 1);
+              gimp_filter_history_add (gimp, procedure);
-
+            }
-      plug_in_procedure_execute (procedure, gimp, display, args, n_args);
+        }
 
       gimp_value_array_unref (args);
     }
 }
 
-void
-plug_in_history_cmd_callback (GtkAction           *action,
-                              GimpPlugInProcedure *procedure,
-                              gpointer             data)
-{
-  Gimp           *gimp;
-  GimpDisplay    *display;
-  GimpValueArray *args;
-  gint            n_args;
-  return_if_no_gimp (gimp, data);
-  return_if_no_display (display, data);
-
-  args = gimp_procedure_get_arguments (GIMP_PROCEDURE (procedure));
-
-  g_value_set_int (gimp_value_array_index (args, 0), GIMP_RUN_INTERACTIVE);
-
-  n_args = plug_in_collect_display_args (action, display,
-                                         GIMP_PROCEDURE (procedure)->args,
-                                         args, 1);
-
-  plug_in_procedure_execute (procedure, gimp, display, args, n_args);
-
-  gimp_value_array_unref (args);
-}
-
 void
 plug_in_reset_all_cmd_callback (GtkAction *action,
                                 gpointer   data)
@@ -261,216 +166,44 @@ plug_in_reset_all_cmd_callback (GtkAction *action,
   GtkWidget *dialog;
   return_if_no_gimp (gimp, data);
 
-  dialog = gimp_message_dialog_new (_("Reset all Filters"), GIMP_STOCK_QUESTION,
+#define RESET_FILTERS_DIALOG_KEY "gimp-reset-all-filters-dialog"
-                                    NULL, 0,
-                                    gimp_standard_help_func, NULL,
 
-                                    GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+  dialog = dialogs_get_dialog (G_OBJECT (gimp), RESET_FILTERS_DIALOG_KEY);
-                                    GIMP_STOCK_RESET, GTK_RESPONSE_OK,
 
-                                    NULL);
+  if (! dialog)
+    {
+      dialog = gimp_message_dialog_new (_("Reset all Filters"),
+                                        GIMP_STOCK_QUESTION,
+                                        NULL, 0,
+                                        gimp_standard_help_func, NULL,
 
-  gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
+                                        GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
-                                           GTK_RESPONSE_OK,
+                                        GIMP_STOCK_RESET, GTK_RESPONSE_OK,
-                                           GTK_RESPONSE_CANCEL,
-                                           -1);
 
-  g_signal_connect (dialog, "response",
+                                        NULL);
-                    G_CALLBACK (plug_in_reset_all_response),
-                    gimp);
 
-  gimp_message_box_set_primary_text (GIMP_MESSAGE_DIALOG (dialog)->box,
+      gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
-                                     _("Do you really want to reset all "
+                                               GTK_RESPONSE_OK,
-                                       "filters to default values?"));
+                                               GTK_RESPONSE_CANCEL,
+                                               -1);
 
-  gtk_widget_show (dialog);
+      g_signal_connect (dialog, "response",
+                        G_CALLBACK (plug_in_reset_all_response),
+                        gimp);
+
+      gimp_message_box_set_primary_text (GIMP_MESSAGE_DIALOG (dialog)->box,
+                                         _("Do you really want to reset all "
+                                           "filters to default values?"));
+
+      dialogs_attach_dialog (G_OBJECT (gimp), RESET_FILTERS_DIALOG_KEY, dialog);
+    }
+
+  gtk_window_present (GTK_WINDOW (dialog));
 }
 
 
 /*  private functions  */
 
-static void
-plug_in_procedure_execute (GimpPlugInProcedure *procedure,
-                           Gimp                *gimp,
-                           GimpDisplay         *display,
-                           GimpValueArray      *args,
-                           gint                 n_args)
-{
-  GError *error = NULL;
-
-  gimp_value_array_truncate (args, n_args);
-
-  /* run the plug-in procedure */
-  gimp_procedure_execute_async (GIMP_PROCEDURE (procedure), gimp,
-                                gimp_get_user_context (gimp),
-                                GIMP_PROGRESS (display), args,
-                                GIMP_OBJECT (display), &error);
-
-  if (error)
-    {
-      gimp_message_literal (gimp,
-                            G_OBJECT (display), GIMP_MESSAGE_ERROR,
-                            error->message);
-      g_error_free (error);
-    }
-  else
-    {
-      /* remember only image plug-ins */
-      if (GIMP_PROCEDURE (procedure)->num_args  >= 2  &&
-          GIMP_IS_PARAM_SPEC_IMAGE_ID (GIMP_PROCEDURE (procedure)->args[1]))
-        {
-          gimp_plug_in_manager_history_add (gimp->plug_in_manager, procedure);
-        }
-    }
-}
-
-static gint
-plug_in_collect_data_args (GtkAction       *action,
-                           GimpObject      *object,
-                           GParamSpec     **pspecs,
-                           GimpValueArray  *args,
-                           gint             n_args)
-{
-  if (gimp_value_array_length (args) > n_args &&
-      GIMP_IS_PARAM_SPEC_STRING (pspecs[n_args]))
-    {
-      if (object)
-        {
-          g_value_set_string (gimp_value_array_index (args, n_args),
-                              gimp_object_get_name (object));
-          n_args++;
-        }
-      else
-        {
-          g_warning ("Uh-oh, no active data object for the plug-in!");
-          return -1;
-        }
-    }
-
-  return n_args;
-}
-
-static gint
-plug_in_collect_image_args (GtkAction       *action,
-                            GimpImage       *image,
-                            GParamSpec     **pspecs,
-                            GimpValueArray  *args,
-                            gint             n_args)
-{
-  if (gimp_value_array_length (args) > n_args &&
-      GIMP_IS_PARAM_SPEC_IMAGE_ID (pspecs[n_args]))
-    {
-      if (image)
-        {
-          gimp_value_set_image (gimp_value_array_index (args, n_args), image);
-          n_args++;
-        }
-      else
-        {
-          g_warning ("Uh-oh, no active image for the plug-in!");
-          return -1;
-        }
-    }
-
-  return n_args;
-}
-
-static gint
-plug_in_collect_item_args (GtkAction       *action,
-                           GimpImage       *image,
-                           GimpItem        *item,
-                           GParamSpec     **pspecs,
-                           GimpValueArray  *args,
-                           gint             n_args)
-{
-  if (gimp_value_array_length (args) > n_args &&
-      GIMP_IS_PARAM_SPEC_IMAGE_ID (pspecs[n_args]))
-    {
-      if (image)
-        {
-          gimp_value_set_image (gimp_value_array_index (args, n_args), image);
-          n_args++;
-
-          if (gimp_value_array_length (args) > n_args &&
-              GIMP_IS_PARAM_SPEC_ITEM_ID (pspecs[n_args]))
-            {
-              if (item &&
-                  g_type_is_a (G_TYPE_FROM_INSTANCE (item),
-                               GIMP_PARAM_SPEC_ITEM_ID (pspecs[n_args])->item_type))
-                {
-                  gimp_value_set_item (gimp_value_array_index (args, n_args),
-                                       item);
-                  n_args++;
-                }
-              else
-                {
-                  g_warning ("Uh-oh, no active item for the plug-in!");
-                  return -1;
-                }
-            }
-        }
-    }
-
-  return n_args;
-}
-
-static gint
-plug_in_collect_display_args (GtkAction       *action,
-                              GimpDisplay     *display,
-                              GParamSpec     **pspecs,
-                              GimpValueArray  *args,
-                              gint             n_args)
-{
-  if (gimp_value_array_length (args) > n_args &&
-      GIMP_IS_PARAM_SPEC_DISPLAY_ID (pspecs[n_args]))
-    {
-      if (display)
-        {
-          gimp_value_set_display (gimp_value_array_index (args, n_args),
-                                  GIMP_OBJECT (display));
-          n_args++;
-        }
-      else
-        {
-          g_warning ("Uh-oh, no active display for the plug-in!");
-          return -1;
-        }
-    }
-
-  if (gimp_value_array_length (args) > n_args &&
-      GIMP_IS_PARAM_SPEC_IMAGE_ID (pspecs[n_args]))
-    {
-      GimpImage *image = display ? gimp_display_get_image (display) : NULL;
-
-      if (image)
-        {
-          gimp_value_set_image (gimp_value_array_index (args, n_args),
-                                image);
-          n_args++;
-
-          if (gimp_value_array_length (args) > n_args &&
-              GIMP_IS_PARAM_SPEC_DRAWABLE_ID (pspecs[n_args]))
-            {
-              GimpDrawable *drawable = gimp_image_get_active_drawable (image);
-
-              if (drawable)
-                {
-                  gimp_value_set_drawable (gimp_value_array_index (args, n_args),
-                                           drawable);
-                  n_args++;
-                }
-              else
-                {
-                  g_warning ("Uh-oh, no active drawable for the plug-in!");
-                  return -1;
-                }
-            }
-        }
-    }
-
-  return n_args;
-}
-
 static void
 plug_in_reset_all_response (GtkWidget *dialog,
                             gint       response_id,

app/actions/plug-in-commands.h

@@ -19,18 +19,12 @@
 #define __PLUG_IN_COMMANDS_H__
 
 
-void   plug_in_run_cmd_callback       (GtkAction           *action,
+void   plug_in_run_cmd_callback       (GtkAction     *action,
-                                       GimpPlugInProcedure *proc,
+                                       GimpProcedure *proc,
-                                       gpointer             data);
+                                       gpointer       data);
-void   plug_in_repeat_cmd_callback    (GtkAction           *action,
-                                       gint                 value,
-                                       gpointer             data);
-void   plug_in_history_cmd_callback   (GtkAction           *action,
-                                       GimpPlugInProcedure *proc,
-                                       gpointer             data);
 
-void   plug_in_reset_all_cmd_callback (GtkAction           *action,
+void   plug_in_reset_all_cmd_callback (GtkAction     *action,
-                                       gpointer             data);
+                                       gpointer       data);
 
 
 #endif /* __PLUG_IN_COMMANDS_H__ */

app/actions/procedure-commands.c

@@ -0,0 +1,283 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <gegl.h>
+#include <gtk/gtk.h>
+
+#include "libgimpbase/gimpbase.h"
+
+#include "actions-types.h"
+
+#include "core/gimp.h"
+#include "core/gimpimage.h"
+#include "core/gimpparamspecs.h"
+#include "core/gimpprogress.h"
+
+#include "pdb/gimpprocedure.h"
+
+#include "display/gimpdisplay.h"
+
+#include "procedure-commands.h"
+
+
+GimpValueArray *
+procedure_commands_get_run_mode_arg (GimpProcedure *procedure)
+{
+  GimpValueArray *args;
+  gint            n_args = 0;
+
+  args = gimp_procedure_get_arguments (procedure);
+
+  /* initialize the first argument  */
+  if (gimp_value_array_length (args) > n_args &&
+      GIMP_IS_PARAM_SPEC_INT32 (procedure->args[n_args]))
+    {
+      g_value_set_int (gimp_value_array_index (args, n_args),
+                       GIMP_RUN_INTERACTIVE);
+      n_args++;
+    }
+
+  gimp_value_array_truncate (args, n_args);
+
+  return args;
+}
+
+GimpValueArray *
+procedure_commands_get_data_args (GimpProcedure *procedure,
+                                  GimpObject    *object)
+{
+  GimpValueArray *args;
+  gint            n_args = 0;
+
+  args = gimp_procedure_get_arguments (procedure);
+
+  /* initialize the first argument  */
+  g_value_set_int (gimp_value_array_index (args, n_args),
+                   GIMP_RUN_INTERACTIVE);
+  n_args++;
+
+  if (gimp_value_array_length (args) > n_args &&
+      GIMP_IS_PARAM_SPEC_STRING (procedure->args[n_args]))
+    {
+      if (object)
+        {
+          g_value_set_string (gimp_value_array_index (args, n_args),
+                              gimp_object_get_name (object));
+          n_args++;
+        }
+      else
+        {
+          g_warning ("Uh-oh, no active data object for the plug-in!");
+          gimp_value_array_unref (args);
+          return NULL;
+        }
+    }
+
+  gimp_value_array_truncate (args, n_args);
+
+  return args;
+}
+
+GimpValueArray *
+procedure_commands_get_image_args (GimpProcedure   *procedure,
+                                   GimpImage       *image)
+{
+  GimpValueArray *args;
+  gint            n_args = 0;
+
+  args = gimp_procedure_get_arguments (procedure);
+
+  /* initialize the first argument  */
+  g_value_set_int (gimp_value_array_index (args, n_args),
+                   GIMP_RUN_INTERACTIVE);
+  n_args++;
+
+  if (gimp_value_array_length (args) > n_args &&
+      GIMP_IS_PARAM_SPEC_IMAGE_ID (procedure->args[n_args]))
+    {
+      if (image)
+        {
+          gimp_value_set_image (gimp_value_array_index (args, n_args), image);
+          n_args++;
+        }
+      else
+        {
+          g_warning ("Uh-oh, no active image for the plug-in!");
+          gimp_value_array_unref (args);
+          return NULL;
+        }
+    }
+
+  gimp_value_array_truncate (args, n_args);
+
+  return args;
+}
+
+GimpValueArray *
+procedure_commands_get_item_args (GimpProcedure *procedure,
+                                  GimpImage     *image,
+                                  GimpItem      *item)
+{
+  GimpValueArray *args;
+  gint            n_args = 0;
+
+  args = gimp_procedure_get_arguments (procedure);
+
+  /* initialize the first argument  */
+  g_value_set_int (gimp_value_array_index (args, n_args),
+                   GIMP_RUN_INTERACTIVE);
+  n_args++;
+
+  if (gimp_value_array_length (args) > n_args &&
+      GIMP_IS_PARAM_SPEC_IMAGE_ID (procedure->args[n_args]))
+    {
+      if (image)
+        {
+          gimp_value_set_image (gimp_value_array_index (args, n_args), image);
+          n_args++;
+
+          if (gimp_value_array_length (args) > n_args &&
+              GIMP_IS_PARAM_SPEC_ITEM_ID (procedure->args[n_args]))
+            {
+              if (item &&
+                  g_type_is_a (G_TYPE_FROM_INSTANCE (item),
+                               GIMP_PARAM_SPEC_ITEM_ID (procedure->args[n_args])->item_type))
+                {
+                  gimp_value_set_item (gimp_value_array_index (args, n_args),
+                                       item);
+                  n_args++;
+                }
+              else
+                {
+                  g_warning ("Uh-oh, no active item for the plug-in!");
+                  gimp_value_array_unref (args);
+                  return NULL;
+                }
+            }
+        }
+    }
+
+  gimp_value_array_truncate (args, n_args);
+
+  return args;
+}
+
+GimpValueArray *
+procedure_commands_get_display_args (GimpProcedure *procedure,
+                                     GimpDisplay   *display)
+{
+  GimpValueArray *args;
+  gint            n_args = 0;
+
+  args = gimp_procedure_get_arguments (procedure);
+
+  /* initialize the first argument  */
+  g_value_set_int (gimp_value_array_index (args, n_args),
+                   GIMP_RUN_INTERACTIVE);
+  n_args++;
+
+  if (gimp_value_array_length (args) > n_args &&
+      GIMP_IS_PARAM_SPEC_DISPLAY_ID (procedure->args[n_args]))
+    {
+      if (display)
+        {
+          gimp_value_set_display (gimp_value_array_index (args, n_args),
+                                  GIMP_OBJECT (display));
+          n_args++;
+        }
+      else
+        {
+          g_warning ("Uh-oh, no active display for the plug-in!");
+          gimp_value_array_unref (args);
+          return NULL;
+        }
+    }
+
+  if (gimp_value_array_length (args) > n_args &&
+      GIMP_IS_PARAM_SPEC_IMAGE_ID (procedure->args[n_args]))
+    {
+      GimpImage *image = display ? gimp_display_get_image (display) : NULL;
+
+      if (image)
+        {
+          gimp_value_set_image (gimp_value_array_index (args, n_args),
+                                image);
+          n_args++;
+
+          if (gimp_value_array_length (args) > n_args &&
+              GIMP_IS_PARAM_SPEC_DRAWABLE_ID (procedure->args[n_args]))
+            {
+              GimpDrawable *drawable = gimp_image_get_active_drawable (image);
+
+              if (drawable)
+                {
+                  gimp_value_set_drawable (gimp_value_array_index (args, n_args),
+                                           drawable);
+                  n_args++;
+                }
+              else
+                {
+                  g_warning ("Uh-oh, no active drawable for the plug-in!");
+                  gimp_value_array_unref (args);
+                  return NULL;
+                }
+            }
+        }
+    }
+
+  gimp_value_array_truncate (args, n_args);
+
+  return args;
+}
+
+gboolean
+procedure_commands_run_procedure (GimpProcedure  *procedure,
+                                  Gimp           *gimp,
+                                  GimpProgress   *progress,
+                                  GimpRunMode     run_mode,
+                                  GimpValueArray *args,
+                                  GimpDisplay    *display)
+{
+  GError *error = NULL;
+
+  g_return_val_if_fail (GIMP_IS_PROCEDURE (procedure), FALSE);
+  g_return_val_if_fail (GIMP_IS_GIMP (gimp), FALSE);
+  g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), FALSE);
+  g_return_val_if_fail (display == NULL || GIMP_IS_DISPLAY (display), FALSE);
+  g_return_val_if_fail (args != NULL, FALSE);
+
+  g_value_set_int (gimp_value_array_index (args, 0), run_mode);
+
+  gimp_procedure_execute_async (procedure, gimp,
+                                gimp_get_user_context (gimp),
+                                progress, args,
+                                GIMP_OBJECT (display), &error);
+
+  if (error)
+    {
+      gimp_message_literal (gimp,
+                            G_OBJECT (progress), GIMP_MESSAGE_ERROR,
+                            error->message);
+      g_clear_error (&error);
+
+      return FALSE;
+    }
+
+  return TRUE;
+}

app/actions/procedure-commands.h

@@ -0,0 +1,41 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __PROCEDURE_COMMANDS_H__
+#define __PROCEDURE_COMMANDS_H__
+
+
+GimpValueArray * procedure_commands_get_run_mode_arg (GimpProcedure  *procedure);
+GimpValueArray * procedure_commands_get_data_args    (GimpProcedure  *procedure,
+                                                      GimpObject     *object);
+GimpValueArray * procedure_commands_get_image_args   (GimpProcedure  *procedure,
+                                                      GimpImage      *image);
+GimpValueArray * procedure_commands_get_item_args    (GimpProcedure  *procedure,
+                                                      GimpImage      *image,
+                                                      GimpItem       *item);
+GimpValueArray * procedure_commands_get_display_args (GimpProcedure  *procedure,
+                                                      GimpDisplay    *display);
+
+gboolean         procedure_commands_run_procedure    (GimpProcedure  *procedure,
+                                                      Gimp           *gimp,
+                                                      GimpProgress   *progress,
+                                                      GimpRunMode     run_mode,
+                                                      GimpValueArray *args,
+                                                      GimpDisplay    *display);
+
+
+#endif /* __PROCEDURE_COMMANDS_H__ */

app/actions/quick-mask-commands.c

@@ -32,7 +32,9 @@
 
 #include "widgets/gimphelp-ids.h"
 
+#include "dialogs/dialogs.h"
 #include "dialogs/channel-options-dialog.h"
+#include "dialogs/item-options-dialog.h"
 
 #include "actions.h"
 #include "quick-mask-commands.h"
@@ -42,9 +44,19 @@
 
 /*  local function prototypes  */
 
-static void   quick_mask_configure_response (GtkWidget            *widget,
+static void   quick_mask_configure_callback (GtkWidget     *dialog,
-                                             gint                  response_id,
+                                             GimpImage     *image,
-                                             ChannelOptionsDialog *options);
+                                             GimpChannel   *channel,
+                                             GimpContext   *context,
+                                             const gchar   *channel_name,
+                                             const GimpRGB *channel_color,
+                                             gboolean       save_selection,
+                                             gboolean       channel_visible,
+                                             gboolean       channel_linked,
+                                             GimpColorTag   channel_color_tag,
+                                             gboolean       channel_lock_content,
+                                             gboolean       channel_lock_position,
+                                             gpointer       user_data);
 
 
 /*  public functionss */
@@ -88,60 +100,78 @@ void
 quick_mask_configure_cmd_callback (GtkAction *action,
                                    gpointer   data)
 {
-  ChannelOptionsDialog *options;
+  GimpImage *image;
-  GimpImage            *image;
+  GtkWidget *widget;
-  GtkWidget            *widget;
+  GtkWidget *dialog;
-  GimpRGB               color;
   return_if_no_image (image, data);
   return_if_no_widget (widget, data);
 
-  gimp_image_get_quick_mask_color (image, &color);
+#define CONFIGURE_DIALOG_KEY "gimp-image-quick-mask-configure-dialog"
 
-  options = channel_options_dialog_new (image, NULL,
+  dialog = dialogs_get_dialog (G_OBJECT (image), CONFIGURE_DIALOG_KEY);
-                                        action_data_get_context (data),
-                                        widget,
-                                        &color,
-                                        NULL,
-                                        _("Quick Mask Attributes"),
-                                        "gimp-quick-mask-edit",
-                                        GIMP_STOCK_QUICK_MASK_ON,
-                                        _("Edit Quick Mask Attributes"),
-                                        GIMP_HELP_QUICK_MASK_EDIT,
-                                        _("Edit Quick Mask Color"),
-                                        _("_Mask opacity:"),
-                                        FALSE);
 
-  g_signal_connect (options->dialog, "response",
+  if (! dialog)
-                    G_CALLBACK (quick_mask_configure_response),
+    {
-                    options);
+      GimpRGB color;
 
-  gtk_widget_show (options->dialog);
+      gimp_image_get_quick_mask_color (image, &color);
+
+      dialog = channel_options_dialog_new (image, NULL,
+                                           action_data_get_context (data),
+                                           widget,
+                                           _("Quick Mask Attributes"),
+                                           "gimp-quick-mask-edit",
+                                           GIMP_STOCK_QUICK_MASK_ON,
+                                           _("Edit Quick Mask Attributes"),
+                                           GIMP_HELP_QUICK_MASK_EDIT,
+                                           _("Edit Quick Mask Color"),
+                                           _("_Mask opacity:"),
+                                           FALSE,
+                                           NULL,
+                                           &color,
+                                           FALSE,
+                                           FALSE,
+                                           GIMP_COLOR_TAG_NONE,
+                                           FALSE,
+                                           FALSE,
+                                           quick_mask_configure_callback,
+                                           NULL);
+
+      item_options_dialog_set_switches_visible (dialog, FALSE);
+
+      dialogs_attach_dialog (G_OBJECT (image), CONFIGURE_DIALOG_KEY, dialog);
+    }
+
+  gtk_window_present (GTK_WINDOW (dialog));
 }
 
 
 /*  private functions  */
 
 static void
-quick_mask_configure_response (GtkWidget            *widget,
+quick_mask_configure_callback (GtkWidget     *dialog,
-                               gint                  response_id,
+                               GimpImage     *image,
-                               ChannelOptionsDialog *options)
+                               GimpChannel   *channel,
+                               GimpContext   *context,
+                               const gchar   *channel_name,
+                               const GimpRGB *channel_color,
+                               gboolean       save_selection,
+                               gboolean       channel_visible,
+                               gboolean       channel_linked,
+                               GimpColorTag   channel_color_tag,
+                               gboolean       channel_lock_content,
+                               gboolean       channel_lock_position,
+                               gpointer       user_data)
 {
-  if (response_id == GTK_RESPONSE_OK)
+  GimpRGB old_color;
+
+  gimp_image_get_quick_mask_color (image, &old_color);
+
+  if (gimp_rgba_distance (&old_color, channel_color) > 0.0001)
     {
-      GimpRGB old_color;
+      gimp_image_set_quick_mask_color (image, channel_color);
-      GimpRGB new_color;
+      gimp_image_flush (image);
-
-      gimp_image_get_quick_mask_color (options->image, &old_color);
-      gimp_color_button_get_color (GIMP_COLOR_BUTTON (options->color_panel),
-                                   &new_color);
-
-      if (gimp_rgba_distance (&old_color, &new_color) > 0.0001)
-        {
-          gimp_image_set_quick_mask_color (options->image, &new_color);
-
-          gimp_image_flush (options->image);
-        }
     }
 
-  gtk_widget_destroy (options->dialog);
+  gtk_widget_destroy (dialog);
 }

app/actions/sample-points-commands.c

@@ -17,21 +17,14 @@
 
 #include "config.h"
 
-#include <gegl.h>
 #include <gtk/gtk.h>
 
-#include "libgimpbase/gimpbase.h"
-#include "libgimpwidgets/gimpwidgets.h"
-
 #include "actions-types.h"
 
-#include "widgets/gimphelp-ids.h"
 #include "widgets/gimpsamplepointeditor.h"
 
 #include "sample-points-commands.h"
 
-#include "gimp-intl.h"
-
 
 /*  public functions  */
 

app/actions/select-actions.c

@@ -40,7 +40,7 @@
 
 static const GimpActionEntry select_actions[] =
 {
-  { "selection-popup", GIMP_STOCK_TOOL_RECT_SELECT,
+  { "selection-popup", GIMP_STOCK_SELECTION,
     NC_("select-action", "Selection Editor Menu"), NULL, NULL, NULL,
     GIMP_HELP_SELECTION_DIALOG },
 
@@ -101,12 +101,30 @@ static const GimpActionEntry select_actions[] =
     G_CALLBACK (select_border_cmd_callback),
     GIMP_HELP_SELECTION_BORDER },
 
+  { "select-flood", NULL,
+    NC_("select-action", "Re_move Holes"), NULL,
+    NC_("select-action", "Remove holes from the selection"),
+    G_CALLBACK (select_flood_cmd_callback),
+    GIMP_HELP_SELECTION_FLOOD },
+
   { "select-save", GIMP_STOCK_SELECTION_TO_CHANNEL,
     NC_("select-action", "Save to _Channel"), NULL,
     NC_("select-action", "Save the selection to a channel"),
     G_CALLBACK (select_save_cmd_callback),
     GIMP_HELP_SELECTION_TO_CHANNEL },
 
+  { "select-fill", GIMP_STOCK_TOOL_BUCKET_FILL,
+    NC_("select-action", "_Fill Selection Outline..."), NULL,
+    NC_("select-action", "Fill the selection outline"),
+    G_CALLBACK (select_fill_cmd_callback),
+    GIMP_HELP_SELECTION_FILL },
+
+  { "select-fill-last-values", GIMP_STOCK_TOOL_BUCKET_FILL,
+    NC_("select-action", "_Fill Selection Outline"), NULL,
+    NC_("select-action", "Fill the selection outline with last used values"),
+    G_CALLBACK (select_fill_last_vals_cmd_callback),
+    GIMP_HELP_SELECTION_FILL },
+
   { "select-stroke", GIMP_STOCK_SELECTION_STROKE,
     NC_("select-action", "_Stroke Selection..."), NULL,
     NC_("select-action", "Paint along the selection outline"),
@@ -169,8 +187,11 @@ select_actions_update (GimpActionGroup *group,
   SET_SENSITIVE ("select-shrink",  drawable && sel);
   SET_SENSITIVE ("select-grow",    drawable && sel);
   SET_SENSITIVE ("select-border",  drawable && sel);
+  SET_SENSITIVE ("select-flood",   drawable && sel);
 
   SET_SENSITIVE ("select-save",               drawable && !fs);
+  SET_SENSITIVE ("select-fill",               writable && !children && sel);
+  SET_SENSITIVE ("select-fill-last-values",   writable && !children && sel);
   SET_SENSITIVE ("select-stroke",             writable && !children && sel);
   SET_SENSITIVE ("select-stroke-last-values", writable && !children && sel);
 

app/actions/select-commands.c

@@ -25,11 +25,12 @@
 
 #include "actions-types.h"
 
+#include "config/gimpdialogconfig.h"
+
 #include "core/gimp.h"
 #include "core/gimpchannel.h"
 #include "core/gimpimage.h"
 #include "core/gimpselection.h"
-#include "core/gimpstrokeoptions.h"
 
 #include "widgets/gimphelp-ids.h"
 #include "widgets/gimpdialogfactory.h"
@@ -39,9 +40,10 @@
 #include "display/gimpdisplay.h"
 #include "display/gimpdisplayshell.h"
 
-#include "dialogs/stroke-dialog.h"
+#include "dialogs/dialogs.h"
 
 #include "actions.h"
+#include "items-commands.h"
 #include "select-commands.h"
 
 #include "gimp-intl.h"
@@ -67,30 +69,8 @@ static void   select_shrink_callback  (GtkWidget *widget,
                                        gpointer   data);
 
 
-/*  private variables  */
-
-static gdouble   select_feather_radius    = 5.0;
-static gint      select_grow_pixels       = 1;
-static gint      select_shrink_pixels     = 1;
-static gboolean  select_shrink_edge_lock  = FALSE;
-static gint      select_border_radius     = 5;
-static gboolean  select_border_feather    = FALSE;
-static gboolean  select_border_edge_lock  = FALSE;
-
-
 /*  public functions  */
 
-void
-select_invert_cmd_callback (GtkAction *action,
-                            gpointer   data)
-{
-  GimpImage *image;
-  return_if_no_image (image, data);
-
-  gimp_channel_invert (gimp_image_get_mask (image), TRUE);
-  gimp_image_flush (image);
-}
-
 void
 select_all_cmd_callback (GtkAction *action,
                          gpointer   data)
@@ -113,6 +93,17 @@ select_none_cmd_callback (GtkAction *action,
   gimp_image_flush (image);
 }
 
+void
+select_invert_cmd_callback (GtkAction *action,
+                            gpointer   data)
+{
+  GimpImage *image;
+  return_if_no_image (image, data);
+
+  gimp_channel_invert (gimp_image_get_mask (image), TRUE);
+  gimp_image_flush (image);
+}
+
 void
 select_float_cmd_callback (GtkAction *action,
                            gpointer   data)
@@ -146,26 +137,38 @@ select_feather_cmd_callback (GtkAction *action,
   GimpDisplay *display;
   GimpImage   *image;
   GtkWidget   *dialog;
-  gdouble      xres;
-  gdouble      yres;
   return_if_no_display (display, data);
 
   image = gimp_display_get_image (display);
 
-  gimp_image_get_resolution (image, &xres, &yres);
+#define FEATHER_DIALOG_KEY "gimp-selection-feather-dialog"
 
-  dialog = gimp_query_size_box (_("Feather Selection"),
+  dialog = dialogs_get_dialog (G_OBJECT (image), FEATHER_DIALOG_KEY);
-                                GTK_WIDGET (gimp_display_get_shell (display)),
+
-                                gimp_standard_help_func,
+  if (! dialog)
-                                GIMP_HELP_SELECTION_FEATHER,
+    {
-                                _("Feather selection by"),
+      GimpDialogConfig *config = GIMP_DIALOG_CONFIG (image->gimp->config);
-                                select_feather_radius, 0, 32767, 3,
+      gdouble           xres;
-                                gimp_display_get_shell (display)->unit,
+      gdouble           yres;
-                                MIN (xres, yres),
+
-                                FALSE,
+      gimp_image_get_resolution (image, &xres, &yres);
-                                G_OBJECT (image), "disconnect",
+
-                                select_feather_callback, image);
+      dialog = gimp_query_size_box (_("Feather Selection"),
-  gtk_widget_show (dialog);
+                                    GTK_WIDGET (gimp_display_get_shell (display)),
+                                    gimp_standard_help_func,
+                                    GIMP_HELP_SELECTION_FEATHER,
+                                    _("Feather selection by"),
+                                    config->selection_feather_radius, 0, 32767, 3,
+                                    gimp_display_get_shell (display)->unit,
+                                    MIN (xres, yres),
+                                    FALSE,
+                                    G_OBJECT (image), "disconnect",
+                                    select_feather_callback, image);
+
+      dialogs_attach_dialog (G_OBJECT (image), FEATHER_DIALOG_KEY, dialog);
+    }
+
+  gtk_window_present (GTK_WINDOW (dialog));
 }
 
 void
@@ -186,41 +189,52 @@ select_shrink_cmd_callback (GtkAction *action,
   GimpDisplay *display;
   GimpImage   *image;
   GtkWidget   *dialog;
-  GtkWidget   *button;
-  gdouble      xres;
-  gdouble      yres;
   return_if_no_display (display, data);
 
   image = gimp_display_get_image (display);
 
-  gimp_image_get_resolution (image, &xres, &yres);
+#define SHRINK_DIALOG_KEY "gimp-selection-shrink-dialog"
 
-  dialog = gimp_query_size_box (_("Shrink Selection"),
+  dialog = dialogs_get_dialog (G_OBJECT (image), SHRINK_DIALOG_KEY);
-                                GTK_WIDGET (gimp_display_get_shell (display)),
-                                gimp_standard_help_func,
-                                GIMP_HELP_SELECTION_SHRINK,
-                                _("Shrink selection by"),
-                                select_shrink_pixels, 1, 32767, 0,
-                                gimp_display_get_shell (display)->unit,
-                                MIN (xres, yres),
-                                FALSE,
-                                G_OBJECT (image), "disconnect",
-                                select_shrink_callback, image);
 
-  /* Edge lock button */
+  if (! dialog)
-  button = gtk_check_button_new_with_mnemonic (_("_Selected areas continue outside the image"));
+    {
-  g_object_set_data (G_OBJECT (dialog), "edge-lock-toggle", button);
+      GimpDialogConfig *config = GIMP_DIALOG_CONFIG (image->gimp->config);
-  gimp_help_set_help_data (button,
+      GtkWidget        *button;
-                           _("When shrinking, act as if selected areas "
+      gdouble           xres;
-                             "continued outside the image."),
+      gdouble           yres;
-                           NULL);
-  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
-                                select_shrink_edge_lock);
-  gtk_box_pack_start (GTK_BOX (GIMP_QUERY_BOX_VBOX (dialog)), button,
-                      FALSE, FALSE, 0);
-  gtk_widget_show (button);
 
-  gtk_widget_show (dialog);
+      gimp_image_get_resolution (image, &xres, &yres);
+
+      dialog = gimp_query_size_box (_("Shrink Selection"),
+                                    GTK_WIDGET (gimp_display_get_shell (display)),
+                                    gimp_standard_help_func,
+                                    GIMP_HELP_SELECTION_SHRINK,
+                                    _("Shrink selection by"),
+                                    config->selection_shrink_radius, 1, 32767, 0,
+                                    gimp_display_get_shell (display)->unit,
+                                    MIN (xres, yres),
+                                    FALSE,
+                                    G_OBJECT (image), "disconnect",
+                                    select_shrink_callback, image);
+
+      /* Edge lock button */
+      button = gtk_check_button_new_with_mnemonic (_("_Selected areas continue outside the image"));
+      g_object_set_data (G_OBJECT (dialog), "edge-lock-toggle", button);
+      gimp_help_set_help_data (button,
+                               _("When shrinking, act as if selected areas "
+                                 "continued outside the image."),
+                               NULL);
+      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
+                                    config->selection_shrink_edge_lock);
+      gtk_box_pack_start (GTK_BOX (GIMP_QUERY_BOX_VBOX (dialog)), button,
+                          FALSE, FALSE, 0);
+      gtk_widget_show (button);
+
+      dialogs_attach_dialog (G_OBJECT (image), SHRINK_DIALOG_KEY, dialog);
+    }
+
+  gtk_window_present (GTK_WINDOW (dialog));
 }
 
 void
@@ -230,26 +244,38 @@ select_grow_cmd_callback (GtkAction *action,
   GimpDisplay *display;
   GimpImage   *image;
   GtkWidget   *dialog;
-  gdouble      xres;
-  gdouble      yres;
   return_if_no_display (display, data);
 
   image = gimp_display_get_image (display);
 
-  gimp_image_get_resolution (image, &xres, &yres);
+#define GROW_DIALOG_KEY "gimp-selection-grow-dialog"
 
-  dialog = gimp_query_size_box (_("Grow Selection"),
+  dialog = dialogs_get_dialog (G_OBJECT (image), GROW_DIALOG_KEY);
-                                GTK_WIDGET (gimp_display_get_shell (display)),
+
-                                gimp_standard_help_func,
+  if (! dialog)
-                                GIMP_HELP_SELECTION_GROW,
+    {
-                                _("Grow selection by"),
+      GimpDialogConfig *config = GIMP_DIALOG_CONFIG (image->gimp->config);
-                                select_grow_pixels, 1, 32767, 0,
+      gdouble           xres;
-                                gimp_display_get_shell (display)->unit,
+      gdouble           yres;
-                                MIN (xres, yres),
+
-                                FALSE,
+      gimp_image_get_resolution (image, &xres, &yres);
-                                G_OBJECT (image), "disconnect",
+
-                                select_grow_callback, image);
+      dialog = gimp_query_size_box (_("Grow Selection"),
-  gtk_widget_show (dialog);
+                                    GTK_WIDGET (gimp_display_get_shell (display)),
+                                    gimp_standard_help_func,
+                                    GIMP_HELP_SELECTION_GROW,
+                                    _("Grow selection by"),
+                                    config->selection_grow_radius, 1, 32767, 0,
+                                    gimp_display_get_shell (display)->unit,
+                                    MIN (xres, yres),
+                                    FALSE,
+                                    G_OBJECT (image), "disconnect",
+                                    select_grow_callback, image);
+
+      dialogs_attach_dialog (G_OBJECT (image), GROW_DIALOG_KEY, dialog);
+    }
+
+  gtk_window_present (GTK_WINDOW (dialog));
 }
 
 void
@@ -259,52 +285,77 @@ select_border_cmd_callback (GtkAction *action,
   GimpDisplay *display;
   GimpImage   *image;
   GtkWidget   *dialog;
-  GtkWidget   *button;
-  gdouble      xres;
-  gdouble      yres;
   return_if_no_display (display, data);
 
   image = gimp_display_get_image (display);
 
-  gimp_image_get_resolution (image, &xres, &yres);
+#define BORDER_DIALOG_KEY "gimp-selection-border-dialog"
 
-  dialog = gimp_query_size_box (_("Border Selection"),
+  dialog = dialogs_get_dialog (G_OBJECT (image), BORDER_DIALOG_KEY);
-                                GTK_WIDGET (gimp_display_get_shell (display)),
-                                gimp_standard_help_func,
-                                GIMP_HELP_SELECTION_BORDER,
-                                _("Border selection by"),
-                                select_border_radius, 1, 32767, 0,
-                                gimp_display_get_shell (display)->unit,
-                                MIN (xres, yres),
-                                FALSE,
-                                G_OBJECT (image), "disconnect",
-                                select_border_callback, image);
 
-  /* Feather button */
+  if (! dialog)
-  button = gtk_check_button_new_with_mnemonic (_("_Feather border"));
+    {
+      GimpDialogConfig *config = GIMP_DIALOG_CONFIG (image->gimp->config);
+      GtkWidget        *combo;
+      GtkWidget        *button;
+      gdouble           xres;
+      gdouble           yres;
 
-  gtk_box_pack_start (GTK_BOX (GIMP_QUERY_BOX_VBOX (dialog)), button,
+      gimp_image_get_resolution (image, &xres, &yres);
-                      FALSE, FALSE, 0);
 
-  g_object_set_data (G_OBJECT (dialog), "border-feather-toggle", button);
+      dialog = gimp_query_size_box (_("Border Selection"),
-  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
+                                    GTK_WIDGET (gimp_display_get_shell (display)),
-                                select_border_feather);
+                                    gimp_standard_help_func,
-  gtk_widget_show (button);
+                                    GIMP_HELP_SELECTION_BORDER,
+                                    _("Border selection by"),
+                                    config->selection_border_radius, 1, 32767, 0,
+                                    gimp_display_get_shell (display)->unit,
+                                    MIN (xres, yres),
+                                    FALSE,
+                                    G_OBJECT (image), "disconnect",
+                                    select_border_callback, image);
 
-  /* Edge lock button */
+      /* Border style combo */
-  button = gtk_check_button_new_with_mnemonic (_("_Selected areas continue outside the image"));
+      combo = gimp_enum_combo_box_new (GIMP_TYPE_CHANNEL_BORDER_STYLE);
-  g_object_set_data (G_OBJECT (dialog), "edge-lock-toggle", button);
+      gimp_int_combo_box_set_label (GIMP_INT_COMBO_BOX (combo),
-  gimp_help_set_help_data (button,
+                                    _("Border style"));
-                           _("When bordering, act as if selected areas "
-                             "continued outside the image."),
-                           NULL);
-  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
-                                select_border_edge_lock);
-  gtk_box_pack_start (GTK_BOX (GIMP_QUERY_BOX_VBOX (dialog)), button,
-                      FALSE, FALSE, 0);
-  gtk_widget_show (button);
 
-  gtk_widget_show (dialog);
+      gtk_box_pack_start (GTK_BOX (GIMP_QUERY_BOX_VBOX (dialog)), combo,
+                          FALSE, FALSE, 0);
+
+      g_object_set_data (G_OBJECT (dialog), "border-style-combo", combo);
+      gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo),
+                                     config->selection_border_style);
+      gtk_widget_show (combo);
+
+      /* Edge lock button */
+      button = gtk_check_button_new_with_mnemonic (_("_Selected areas continue outside the image"));
+      g_object_set_data (G_OBJECT (dialog), "edge-lock-toggle", button);
+      gimp_help_set_help_data (button,
+                               _("When bordering, act as if selected areas "
+                                 "continued outside the image."),
+                               NULL);
+      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
+                                    config->selection_border_edge_lock);
+      gtk_box_pack_start (GTK_BOX (GIMP_QUERY_BOX_VBOX (dialog)), button,
+                          FALSE, FALSE, 0);
+      gtk_widget_show (button);
+
+      dialogs_attach_dialog (G_OBJECT (image), BORDER_DIALOG_KEY, dialog);
+    }
+
+  gtk_window_present (GTK_WINDOW (dialog));
+}
+
+void
+select_flood_cmd_callback (GtkAction *action,
+                           gpointer   data)
+{
+  GimpImage *image;
+  return_if_no_image (image, data);
+
+  gimp_channel_flood (gimp_image_get_mask (image), TRUE);
+  gimp_image_flush (image);
 }
 
 void
@@ -327,82 +378,62 @@ select_save_cmd_callback (GtkAction *action,
                                              "gimp-channel-list");
 }
 
+void
+select_fill_cmd_callback (GtkAction *action,
+                          gpointer   data)
+{
+  GimpImage *image;
+  return_if_no_image (image, data);
+
+  items_fill_cmd_callback (action,
+                           image, GIMP_ITEM (gimp_image_get_mask (image)),
+                           "gimp-selection-fill-dialog",
+                           _("Fill Selection Outline"),
+                           GIMP_STOCK_TOOL_BUCKET_FILL,
+                           GIMP_HELP_SELECTION_FILL,
+                           data);
+}
+
+void
+select_fill_last_vals_cmd_callback (GtkAction *action,
+                                    gpointer   data)
+{
+  GimpImage *image;
+  return_if_no_image (image, data);
+
+  items_fill_last_vals_cmd_callback (action,
+                                     image,
+                                     GIMP_ITEM (gimp_image_get_mask (image)),
+                                     data);
+}
+
 void
 select_stroke_cmd_callback (GtkAction *action,
                             gpointer   data)
 {
-  GimpImage    *image;
+  GimpImage *image;
-  GimpDrawable *drawable;
-  GtkWidget    *widget;
-  GtkWidget    *dialog;
   return_if_no_image (image, data);
-  return_if_no_widget (widget, data);
 
-  drawable = gimp_image_get_active_drawable (image);
+  items_stroke_cmd_callback (action,
-
+                             image, GIMP_ITEM (gimp_image_get_mask (image)),
-  if (! drawable)
+                             "gimp-selection-stroke-dialog",
-    {
+                             _("Stroke Selection"),
-      gimp_message_literal (image->gimp,
+                             GIMP_STOCK_SELECTION_STROKE,
-                            G_OBJECT (widget), GIMP_MESSAGE_WARNING,
+                             GIMP_HELP_SELECTION_STROKE,
-                            _("There is no active layer or channel to stroke to."));
+                             data);
-      return;
-    }
-
-  dialog = stroke_dialog_new (GIMP_ITEM (gimp_image_get_mask (image)),
-                              action_data_get_context (data),
-                              _("Stroke Selection"),
-                              GIMP_STOCK_SELECTION_STROKE,
-                              GIMP_HELP_SELECTION_STROKE,
-                              widget);
-  gtk_widget_show (dialog);
 }
 
 void
 select_stroke_last_vals_cmd_callback (GtkAction *action,
                                       gpointer   data)
 {
-  GimpImage         *image;
+  GimpImage *image;
-  GimpDrawable      *drawable;
-  GimpContext       *context;
-  GtkWidget         *widget;
-  GimpStrokeOptions *options;
-  GError            *error = NULL;
   return_if_no_image (image, data);
-  return_if_no_context (context, data);
-  return_if_no_widget (widget, data);
 
-  drawable = gimp_image_get_active_drawable (image);
+  items_stroke_last_vals_cmd_callback (action,
-
+                                       image,
-  if (! drawable)
+                                       GIMP_ITEM (gimp_image_get_mask (image)),
-    {
+                                       data);
-      gimp_message_literal (image->gimp,
-                            G_OBJECT (widget), GIMP_MESSAGE_WARNING,
-                            _("There is no active layer or channel to stroke to."));
-      return;
-    }
-
-  options = g_object_get_data (G_OBJECT (image->gimp), "saved-stroke-options");
-
-  if (options)
-    g_object_ref (options);
-  else
-    options = gimp_stroke_options_new (image->gimp, context, TRUE);
-
-  if (! gimp_item_stroke (GIMP_ITEM (gimp_image_get_mask (image)),
-                          drawable, context, options, NULL,
-                          TRUE, NULL, &error))
-    {
-      gimp_message_literal (image->gimp,
-                            G_OBJECT (widget), GIMP_MESSAGE_WARNING,
-                            error->message);
-      g_clear_error (&error);
-    }
-  else
-    {
-      gimp_image_flush (image);
-    }
-
-  g_object_unref (options);
 }
 
 
@@ -414,11 +445,17 @@ select_feather_callback (GtkWidget *widget,
                          GimpUnit   unit,
                          gpointer   data)
 {
-  GimpImage *image = GIMP_IMAGE (data);
+  GimpImage        *image  = GIMP_IMAGE (data);
-  gdouble    radius_x;
+  GimpDialogConfig *config = GIMP_DIALOG_CONFIG (image->gimp->config);
-  gdouble    radius_y;
+  gdouble           radius_x;
+  gdouble           radius_y;
 
-  radius_x = radius_y = select_feather_radius = size;
+  g_object_set (config,
+		"selection-feather-radius", size,
+		NULL);
+
+  radius_x = config->selection_feather_radius;
+  radius_y = config->selection_feather_radius;
 
   if (unit != GIMP_UNIT_PIXEL)
     {
@@ -447,21 +484,28 @@ select_border_callback (GtkWidget *widget,
                         GimpUnit   unit,
                         gpointer   data)
 {
-  GimpImage *image  = GIMP_IMAGE (data);
+  GimpImage        *image  = GIMP_IMAGE (data);
-  GtkWidget *feather_button = g_object_get_data (G_OBJECT (widget),
+  GimpDialogConfig *config = GIMP_DIALOG_CONFIG (image->gimp->config);
-                                                 "border-feather-toggle");
+  GtkWidget        *combo;
-  GtkWidget *edge_lock_button = g_object_get_data (G_OBJECT (widget),
+  GtkWidget        *button;
-                                                   "edge-lock-toggle");
+  gdouble           radius_x;
-  gdouble    radius_x;
+  gdouble           radius_y;
-  gdouble    radius_y;
+  gint              border_style;
 
-  radius_x = radius_y = select_border_radius = ROUND (size);
+  combo  = g_object_get_data (G_OBJECT (widget), "border-style-combo");
+  button = g_object_get_data (G_OBJECT (widget), "edge-lock-toggle");
 
-  select_border_feather =
+  gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (combo), &border_style);
-    gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (feather_button));
 
-  select_border_edge_lock =
+  g_object_set (config,
-    gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (edge_lock_button));
+		"selection-border-radius", size,
+		"selection-border-style",  border_style,
+		"selection-border-edge-lock",
+		gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)),
+		NULL);
+
+  radius_x = ROUND (config->selection_border_radius);
+  radius_y = ROUND (config->selection_border_radius);
 
   if (unit != GIMP_UNIT_PIXEL)
     {
@@ -481,7 +525,9 @@ select_border_callback (GtkWidget *widget,
     }
 
   gimp_channel_border (gimp_image_get_mask (image), radius_x, radius_y,
-                       select_border_feather, select_border_edge_lock, TRUE);
+                       config->selection_border_style,
+		       config->selection_border_edge_lock,
+		       TRUE);
   gimp_image_flush (image);
 }
 
@@ -491,11 +537,17 @@ select_grow_callback (GtkWidget *widget,
                       GimpUnit   unit,
                       gpointer   data)
 {
-  GimpImage *image = GIMP_IMAGE (data);
+  GimpImage        *image  = GIMP_IMAGE (data);
-  gdouble    radius_x;
+  GimpDialogConfig *config = GIMP_DIALOG_CONFIG (image->gimp->config);
-  gdouble    radius_y;
+  gdouble           radius_x;
+  gdouble           radius_y;
 
-  radius_x = radius_y = select_grow_pixels = ROUND (size);
+  g_object_set (config,
+		"selection-grow-radius", size,
+		NULL);
+
+  radius_x = ROUND (config->selection_grow_radius);
+  radius_y = ROUND (config->selection_grow_radius);
 
   if (unit != GIMP_UNIT_PIXEL)
     {
@@ -524,15 +576,22 @@ select_shrink_callback (GtkWidget *widget,
                         GimpUnit   unit,
                         gpointer   data)
 {
-  GimpImage *image  = GIMP_IMAGE (data);
+  GimpImage        *image  = GIMP_IMAGE (data);
-  GtkWidget *button = g_object_get_data (G_OBJECT (widget), "edge-lock-toggle");
+  GimpDialogConfig *config = GIMP_DIALOG_CONFIG (image->gimp->config);
-  gint       radius_x;
+  GtkWidget        *button;
-  gint       radius_y;
+  gint              radius_x;
+  gint              radius_y;
 
-  radius_x = radius_y = select_shrink_pixels = ROUND (size);
+  button = g_object_get_data (G_OBJECT (widget), "edge-lock-toggle");
 
-  select_shrink_edge_lock =
+  g_object_set (config,
-    gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button));
+		"selection-shrink-radius",  size,
+		"selection-shrink-edge-lock",
+		gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)),
+		NULL);
+
+  radius_x = ROUND (config->selection_shrink_radius);
+  radius_y = ROUND (config->selection_shrink_radius);
 
   if (unit != GIMP_UNIT_PIXEL)
     {
@@ -552,6 +611,7 @@ select_shrink_callback (GtkWidget *widget,
     }
 
   gimp_channel_shrink (gimp_image_get_mask (image), radius_x, radius_y,
-                       select_shrink_edge_lock, TRUE);
+                       config->selection_shrink_edge_lock,
+		       TRUE);
   gimp_image_flush (image);
 }

app/actions/select-commands.h

@@ -19,12 +19,12 @@
 #define __SELECT_COMMANDS_H__
 
 
-void   select_invert_cmd_callback           (GtkAction *action,
-                                             gpointer   data);
 void   select_all_cmd_callback              (GtkAction *action,
                                              gpointer   data);
 void   select_none_cmd_callback             (GtkAction *action,
                                              gpointer   data);
+void   select_invert_cmd_callback           (GtkAction *action,
+                                             gpointer   data);
 void   select_float_cmd_callback            (GtkAction *action,
                                              gpointer   data);
 void   select_feather_cmd_callback          (GtkAction *action,
@@ -33,12 +33,19 @@ void   select_sharpen_cmd_callback          (GtkAction *action,
                                              gpointer   data);
 void   select_shrink_cmd_callback           (GtkAction *action,
                                              gpointer   data);
-void   select_border_cmd_callback           (GtkAction *action,
-                                             gpointer   data);
 void   select_grow_cmd_callback             (GtkAction *action,
                                              gpointer   data);
+void   select_border_cmd_callback           (GtkAction *action,
+                                             gpointer   data);
+void   select_flood_cmd_callback            (GtkAction *action,
+                                             gpointer   data);
 void   select_save_cmd_callback             (GtkAction *action,
                                              gpointer   data);
+
+void   select_fill_cmd_callback             (GtkAction *action,
+                                             gpointer   data);
+void   select_fill_last_vals_cmd_callback   (GtkAction *action,
+                                             gpointer   data);
 void   select_stroke_cmd_callback           (GtkAction *action,
                                              gpointer   data);
 void   select_stroke_last_vals_cmd_callback (GtkAction *action,

app/actions/templates-commands.c

@@ -42,6 +42,7 @@
 #include "widgets/gimptemplateview.h"
 #include "widgets/gimpwidgets-utils.h"
 
+#include "dialogs/dialogs.h"
 #include "dialogs/template-options-dialog.h"
 
 #include "actions.h"
@@ -60,16 +61,20 @@ typedef struct
 
 /*  local function prototypes  */
 
-static void   templates_new_response     (GtkWidget             *dialog,
+static void   templates_new_callback     (GtkWidget          *dialog,
-                                          gint                   response_id,
+                                          GimpTemplate       *template,
-                                          TemplateOptionsDialog *options);
+                                          GimpTemplate       *edit_template,
-static void   templates_edit_response    (GtkWidget             *widget,
+                                          GimpContext        *context,
-                                          gint                   response_id,
+                                          gpointer            user_data);
-                                          TemplateOptionsDialog *options);
+static void   templates_edit_callback    (GtkWidget          *dialog,
-static void   templates_delete_response  (GtkWidget             *dialog,
+                                          GimpTemplate       *template,
-                                          gint                   response_id,
+                                          GimpTemplate       *edit_template,
-                                          TemplateDeleteData    *delete_data);
+                                          GimpContext        *context,
-static void   templates_delete_data_free (TemplateDeleteData    *delete_data);
+                                          gpointer            user_data);
+static void   templates_delete_response  (GtkWidget          *dialog,
+                                          gint                response_id,
+                                          TemplateDeleteData *delete_data);
+static void   templates_delete_data_free (TemplateDeleteData *delete_data);
 
 
 /*  public functions */
@@ -109,25 +114,32 @@ void
 templates_new_cmd_callback (GtkAction *action,
                             gpointer   data)
 {
-  GimpContainerEditor   *editor = GIMP_CONTAINER_EDITOR (data);
+  GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
-  GimpContext           *context;
+  GimpContext         *context;
-  TemplateOptionsDialog *options;
+  GtkWidget           *dialog;
 
   context = gimp_container_view_get_context (editor->view);
 
-  options = template_options_dialog_new (NULL, context,
+#define NEW_DIALOG_KEY "gimp-template-new-dialog"
-                                         GTK_WIDGET (editor),
-                                         _("New Template"),
-                                         "gimp-template-new",
-                                         GIMP_STOCK_TEMPLATE,
-                                         _("Create a New Template"),
-                                         GIMP_HELP_TEMPLATE_NEW);
 
-  g_signal_connect (options->dialog, "response",
+  dialog = dialogs_get_dialog (G_OBJECT (context->gimp), NEW_DIALOG_KEY);
-                    G_CALLBACK (templates_new_response),
-                    options);
 
-  gtk_widget_show (options->dialog);
+  if (! dialog)
+    {
+      dialog = template_options_dialog_new (NULL, context,
+                                            GTK_WIDGET (editor),
+                                            _("New Template"),
+                                            "gimp-template-new",
+                                            GIMP_STOCK_TEMPLATE,
+                                            _("Create a New Template"),
+                                            GIMP_HELP_TEMPLATE_NEW,
+                                            templates_new_callback,
+                                            NULL);
+
+      dialogs_attach_dialog (G_OBJECT (context->gimp), NEW_DIALOG_KEY, dialog);
+    }
+
+  gtk_window_present (GTK_WINDOW (dialog));
 }
 
 void
@@ -176,21 +188,28 @@ templates_edit_cmd_callback (GtkAction *action,
 
   if (template && gimp_container_have (container, GIMP_OBJECT (template)))
     {
-      TemplateOptionsDialog *options;
+      GtkWidget *dialog;
 
-      options = template_options_dialog_new (template, context,
+#define EDIT_DIALOG_KEY "gimp-template-edit-dialog"
-                                             GTK_WIDGET (editor),
-                                             _("Edit Template"),
-                                             "gimp-template-edit",
-                                             "gtk-edit",
-                                             _("Edit Template"),
-                                             GIMP_HELP_TEMPLATE_EDIT);
 
-      g_signal_connect (options->dialog, "response",
+      dialog = dialogs_get_dialog (G_OBJECT (template), EDIT_DIALOG_KEY);
-                        G_CALLBACK (templates_edit_response),
-                        options);
 
-      gtk_widget_show (options->dialog);
+      if (! dialog)
+        {
+          dialog = template_options_dialog_new (template, context,
+                                                GTK_WIDGET (editor),
+                                                _("Edit Template"),
+                                                "gimp-template-edit",
+                                                "gtk-edit",
+                                                _("Edit Template"),
+                                                GIMP_HELP_TEMPLATE_EDIT,
+                                                templates_edit_callback,
+                                                NULL);
+
+          dialogs_attach_dialog (G_OBJECT (template), EDIT_DIALOG_KEY, dialog);
+        }
+
+      gtk_window_present (GTK_WINDOW (dialog));
     }
 }
 
@@ -256,40 +275,28 @@ templates_delete_cmd_callback (GtkAction *action,
 /*  private functions  */
 
 static void
-templates_new_response (GtkWidget             *dialog,
+templates_new_callback (GtkWidget    *dialog,
-                        gint                   response_id,
+                        GimpTemplate *template,
-                        TemplateOptionsDialog *options)
+                        GimpTemplate *edit_template,
+                        GimpContext  *context,
+                        gpointer      user_data)
 {
-  if (response_id == GTK_RESPONSE_OK)
+  gimp_container_add (context->gimp->templates, GIMP_OBJECT (edit_template));
-    {
+  gimp_context_set_template (gimp_get_user_context (context->gimp),
-      GimpTemplateEditor *editor = GIMP_TEMPLATE_EDITOR (options->editor);
+                             edit_template);
-      GimpTemplate       *template;
-
-      template = gimp_template_editor_get_template (editor);
-
-      gimp_container_add (options->gimp->templates, GIMP_OBJECT (template));
-      gimp_context_set_template (gimp_get_user_context (options->gimp),
-                                 template);
-    }
 
   gtk_widget_destroy (dialog);
 }
 
 static void
-templates_edit_response (GtkWidget             *dialog,
+templates_edit_callback (GtkWidget    *dialog,
-                         gint                   response_id,
+                         GimpTemplate *template,
-                         TemplateOptionsDialog *options)
+                         GimpTemplate *edit_template,
+                         GimpContext  *context,
+                         gpointer      user_data)
 {
-  if (response_id == GTK_RESPONSE_OK)
+  gimp_config_sync (G_OBJECT (edit_template),
-    {
+                    G_OBJECT (template), 0);
-      GimpTemplateEditor *editor = GIMP_TEMPLATE_EDITOR (options->editor);
-      GimpTemplate       *template;
-
-      template = gimp_template_editor_get_template (editor);
-
-      gimp_config_sync (G_OBJECT (template),
-                        G_OBJECT (options->template), 0);
-    }
 
   gtk_widget_destroy (dialog);
 }

app/actions/text-editor-commands.c

@@ -51,48 +51,43 @@ text_editor_load_cmd_callback (GtkAction *action,
                                gpointer   data)
 {
   GimpTextEditor *editor = GIMP_TEXT_EDITOR (data);
-  GtkFileChooser *chooser;
 
-  if (editor->file_dialog)
+  if (! editor->file_dialog)
     {
-      gtk_window_present (GTK_WINDOW (editor->file_dialog));
+      GtkWidget *dialog;
-      return;
+
+      dialog = editor->file_dialog =
+        gtk_file_chooser_dialog_new (_("Open Text File (UTF-8)"),
+                                     GTK_WINDOW (editor),
+                                     GTK_FILE_CHOOSER_ACTION_OPEN,
+
+                                     GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+                                     GTK_STOCK_OPEN,   GTK_RESPONSE_OK,
+
+                                     NULL);
+
+      gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
+      gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
+                                               GTK_RESPONSE_OK,
+                                               GTK_RESPONSE_CANCEL,
+                                               -1);
+
+      gtk_window_set_role (GTK_WINDOW (dialog), "gimp-text-load-file");
+      gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
+      gtk_window_set_destroy_with_parent (GTK_WINDOW (dialog), TRUE);
+
+      g_object_add_weak_pointer (G_OBJECT (dialog),
+                                 (gpointer) &editor->file_dialog);
+
+      g_signal_connect (dialog, "response",
+                        G_CALLBACK (text_editor_load_response),
+                        editor);
+      g_signal_connect (dialog, "delete-event",
+                        G_CALLBACK (gtk_true),
+                        NULL);
     }
 
-  editor->file_dialog =
+  gtk_window_present (GTK_WINDOW (editor->file_dialog));
-    gtk_file_chooser_dialog_new (_("Open Text File (UTF-8)"),
-                                 GTK_WINDOW (editor),
-                                 GTK_FILE_CHOOSER_ACTION_OPEN,
-
-                                 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
-                                 GTK_STOCK_OPEN,   GTK_RESPONSE_OK,
-
-                                 NULL);
-
-  chooser = GTK_FILE_CHOOSER (editor->file_dialog);
-
-  gtk_dialog_set_alternative_button_order (GTK_DIALOG (editor->file_dialog),
-                                           GTK_RESPONSE_OK,
-                                           GTK_RESPONSE_CANCEL,
-                                           -1);
-
-  g_object_add_weak_pointer (G_OBJECT (chooser),
-                             (gpointer) &editor->file_dialog);
-
-  gtk_window_set_role (GTK_WINDOW (chooser), "gimp-text-load-file");
-  gtk_window_set_position (GTK_WINDOW (chooser), GTK_WIN_POS_MOUSE);
-  gtk_window_set_destroy_with_parent (GTK_WINDOW (chooser), TRUE);
-
-  gtk_dialog_set_default_response (GTK_DIALOG (chooser), GTK_RESPONSE_OK);
-
-  g_signal_connect (chooser, "response",
-                    G_CALLBACK (text_editor_load_response),
-                    editor);
-  g_signal_connect (chooser, "delete-event",
-                    G_CALLBACK (gtk_true),
-                    NULL);
-
-  gtk_widget_show (GTK_WIDGET (chooser));
 }
 
 void

app/actions/text-tool-commands.c

@@ -37,6 +37,8 @@
 
 #include "tools/gimptexttool.h"
 
+#include "dialogs/dialogs.h"
+
 #include "text-tool-commands.h"
 
 #include "gimp-intl.h"
@@ -44,11 +46,9 @@
 
 /*  local function prototypes  */
 
-static void   text_tool_load_dialog_destroyed (GtkWidget    *dialog,
+static void   text_tool_load_dialog_response (GtkWidget    *dialog,
-					       GObject      *tool);
+                                              gint          response_id,
-static void   text_tool_load_dialog_response  (GtkWidget    *dialog,
+                                              GimpTextTool *tool);
-					       gint          response_id,
-					       GimpTextTool *tool);
 
 
 /*  public functions  */
@@ -93,63 +93,54 @@ void
 text_tool_load_cmd_callback (GtkAction *action,
                              gpointer   data)
 {
-  GimpTextTool   *text_tool = GIMP_TEXT_TOOL (data);
+  GimpTextTool *text_tool = GIMP_TEXT_TOOL (data);
-  GtkWidget      *dialog;
+  GtkWidget    *dialog;
-  GtkWidget      *parent    = NULL;
-  GtkFileChooser *chooser;
 
-  dialog = g_object_get_data (G_OBJECT (text_tool), "gimp-text-file-dialog");
+  dialog = dialogs_get_dialog (G_OBJECT (text_tool), "gimp-text-file-dialog");
 
-  if (dialog)
+  if (! dialog)
     {
-      gtk_window_present (GTK_WINDOW (dialog));
+      GtkWidget *parent = NULL;
-      return;
+
+      if (GIMP_TOOL (text_tool)->display)
+        {
+          GimpDisplayShell *shell;
+
+          shell = gimp_display_get_shell (GIMP_TOOL (text_tool)->display);
+
+          parent = gtk_widget_get_toplevel (GTK_WIDGET (shell));
+        }
+
+      dialog = gtk_file_chooser_dialog_new (_("Open Text File (UTF-8)"),
+                                            parent ? GTK_WINDOW (parent) : NULL,
+                                            GTK_FILE_CHOOSER_ACTION_OPEN,
+
+                                            GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+                                            GTK_STOCK_OPEN,   GTK_RESPONSE_OK,
+
+                                            NULL);
+
+      gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
+      gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
+                                               GTK_RESPONSE_OK,
+                                               GTK_RESPONSE_CANCEL,
+                                               -1);
+
+      gtk_window_set_role (GTK_WINDOW (dialog), "gimp-text-load-file");
+      gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
+
+      g_signal_connect (dialog, "response",
+                        G_CALLBACK (text_tool_load_dialog_response),
+                        text_tool);
+      g_signal_connect (dialog, "delete-event",
+                        G_CALLBACK (gtk_true),
+                        NULL);
+
+      dialogs_attach_dialog (G_OBJECT (text_tool),
+                             "gimp-text-file-dialog", dialog);
     }
 
-  if (GIMP_TOOL (text_tool)->display)
+  gtk_window_present (GTK_WINDOW (dialog));
-    {
-      GimpDisplayShell *shell;
-
-      shell = gimp_display_get_shell (GIMP_TOOL (text_tool)->display);
-
-      parent = gtk_widget_get_toplevel (GTK_WIDGET (shell));
-    }
-
-  dialog = gtk_file_chooser_dialog_new (_("Open Text File (UTF-8)"),
-					parent ? GTK_WINDOW (parent) : NULL,
-					GTK_FILE_CHOOSER_ACTION_OPEN,
-
-					GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
-					GTK_STOCK_OPEN,   GTK_RESPONSE_OK,
-
-					NULL);
-
-  chooser = GTK_FILE_CHOOSER (dialog);
-
-  gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
-                                           GTK_RESPONSE_OK,
-                                           GTK_RESPONSE_CANCEL,
-                                           -1);
-
-  g_object_set_data (G_OBJECT (text_tool), "gimp-text-file-dialog", dialog);
-
-  g_signal_connect (dialog, "destroy",
-		    G_CALLBACK (text_tool_load_dialog_destroyed),
-		    text_tool);
-
-  gtk_window_set_role (GTK_WINDOW (chooser), "gimp-text-load-file");
-  gtk_window_set_position (GTK_WINDOW (chooser), GTK_WIN_POS_MOUSE);
-
-  gtk_dialog_set_default_response (GTK_DIALOG (chooser), GTK_RESPONSE_OK);
-
-  g_signal_connect (chooser, "response",
-                    G_CALLBACK (text_tool_load_dialog_response),
-                    text_tool);
-  g_signal_connect (chooser, "delete-event",
-                    G_CALLBACK (gtk_true),
-                    NULL);
-
-  gtk_widget_show (GTK_WIDGET (chooser));
 }
 
 void
@@ -201,13 +192,6 @@ text_tool_direction_cmd_callback (GtkAction *action,
 
 /*  private functions  */
 
-static void
-text_tool_load_dialog_destroyed (GtkWidget *dialog,
-				 GObject   *tool)
-{
-  g_object_set_data (tool, "gimp-text-file-dialog", NULL);
-}
-
 static void
 text_tool_load_dialog_response (GtkWidget    *dialog,
 				gint          response_id,
@@ -215,11 +199,9 @@ text_tool_load_dialog_response (GtkWidget    *dialog,
 {
   if (response_id == GTK_RESPONSE_OK)
     {
-      GFile  *file;
+      GFile  *file  = gtk_file_chooser_get_file (GTK_FILE_CHOOSER (dialog));
       GError *error = NULL;
 
-      file = gtk_file_chooser_get_file (GTK_FILE_CHOOSER (dialog));
-
       if (! gimp_text_buffer_load (tool->buffer, file, &error))
         {
           gimp_message (GIMP_TOOL (tool)->tool_info->gimp, G_OBJECT (dialog),

app/actions/tool-options-actions.c

@@ -201,17 +201,20 @@ tool_options_actions_update_presets (GimpActionGroup *group,
       entry.value_variable = FALSE;
       entry.help_id        = help_id;
 
-      for (list = GIMP_LIST (presets)->list, i = 0;
+      for (list = GIMP_LIST (presets)->queue->head, i = 0;
            list;
            list = g_list_next (list), i++)
         {
           GimpObject *preset = list->data;
+          GdkPixbuf  *pixbuf = NULL;
 
           entry.name      = g_strdup_printf ("%s-%03d", action_prefix, i);
           entry.label     = gimp_object_get_name (preset);
           entry.icon_name = gimp_viewable_get_icon_name (GIMP_VIEWABLE (preset));
           entry.value     = i;
 
+          g_object_get (preset, "icon-pixbuf", &pixbuf, NULL);
+
           gimp_action_group_add_enum_actions (group, NULL, &entry, 1, callback);
 
           if (need_writable)
@@ -222,6 +225,9 @@ tool_options_actions_update_presets (GimpActionGroup *group,
             SET_SENSITIVE (entry.name,
                            gimp_data_is_deletable (GIMP_DATA (preset)));
 
+          if (pixbuf)
+            gimp_action_group_set_action_pixbuf (group, entry.name, pixbuf);
+
           g_free ((gchar *) entry.name);
         }
     }

app/actions/tool-options-commands.c

@@ -175,7 +175,7 @@ tool_options_reset_cmd_callback (GtkAction *action,
   GimpContext  *context   = gimp_get_user_context (gimp_editor_get_ui_manager (editor)->gimp);
   GimpToolInfo *tool_info = gimp_context_get_tool (context);
 
-  gimp_tool_options_reset (tool_info->tool_options);
+  gimp_config_reset (GIMP_CONFIG (tool_info->tool_options));
 }
 
 void
@@ -222,7 +222,7 @@ tool_options_reset_all_cmd_callback (GtkAction *action,
         {
           GimpToolInfo *tool_info = list->data;
 
-          gimp_tool_options_reset (tool_info->tool_options);
+          gimp_config_reset (GIMP_CONFIG (tool_info->tool_options));
         }
     }
 

app/actions/tool-preset-editor-actions.c

@@ -33,6 +33,7 @@
 
 #include "data-editor-commands.h"
 #include "tool-preset-editor-actions.h"
+#include "tool-preset-editor-commands.h"
 
 #include "gimp-intl.h"
 
@@ -41,7 +42,20 @@ static const GimpActionEntry tool_preset_editor_actions[] =
 {
   { "tool-preset-editor-popup", GIMP_STOCK_TOOL_PRESET,
     NC_("tool-preset-editor-action", "Tool Preset Editor Menu"), NULL, NULL, NULL,
-    GIMP_HELP_BRUSH_EDITOR_DIALOG }
+    GIMP_HELP_TOOL_PRESET_EDITOR_DIALOG },
+
+  { "tool-preset-editor-save", "document-save",
+    NC_("tool-preset-editor-action", "_Save Tool Options to Preset"), NULL,
+    NC_("tool-preset-editor-action", "Save the active tool options to this "
+        "tool preset"),
+    G_CALLBACK (tool_preset_editor_save_cmd_callback),
+    GIMP_HELP_TOOL_PRESET_SAVE },
+
+  { "tool-preset-editor-restore", "document-revert",
+    NC_("tool-preset-editor-action", "_Restore Tool Preset"), NULL,
+    NC_("tool-preset-editor-action", "Restore this tool preset"),
+    G_CALLBACK (tool_preset_editor_restore_cmd_callback),
+    GIMP_HELP_TOOL_PRESET_RESTORE }
 };
 
 
@@ -51,7 +65,7 @@ static const GimpToggleActionEntry tool_preset_editor_toggle_actions[] =
     NC_("tool-preset-editor-action", "Edit Active Tool Preset"), NULL, NULL,
     G_CALLBACK (data_editor_edit_active_cmd_callback),
     FALSE,
-    GIMP_HELP_BRUSH_EDITOR_EDIT_ACTIVE }
+    GIMP_HELP_TOOL_PRESET_EDITOR_EDIT_ACTIVE }
 };
 
 
@@ -82,7 +96,9 @@ tool_preset_editor_actions_update (GimpActionGroup *group,
 #define SET_ACTIVE(action,condition) \
         gimp_action_group_set_action_active (group, action, (condition) != 0)
 
-  SET_ACTIVE ("tool-preset-editor-edit-active", edit_active);
+  SET_SENSITIVE ("tool-preset-editor-save",        data_editor->data);
+  SET_SENSITIVE ("tool-preset-editor-restore",     data_editor->data);
+  SET_ACTIVE    ("tool-preset-editor-edit-active", edit_active);
 
 #undef SET_SENSITIVE
 #undef SET_ACTIVE

app/actions/tool-preset-editor-commands.c

@@ -0,0 +1,88 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <gegl.h>
+#include <gtk/gtk.h>
+
+#include "libgimpconfig/gimpconfig.h"
+#include "libgimpwidgets/gimpwidgets.h"
+
+#include "actions-types.h"
+
+#include "core/gimp.h"
+#include "core/gimpcontext.h"
+#include "core/gimptoolinfo.h"
+#include "core/gimptoolpreset.h"
+
+#include "widgets/gimpdataeditor.h"
+
+#include "tool-preset-editor-commands.h"
+
+#include "gimp-intl.h"
+
+
+/*  public functions  */
+
+void
+tool_preset_editor_save_cmd_callback (GtkAction *action,
+                                      gpointer   data)
+{
+  GimpDataEditor *editor  = GIMP_DATA_EDITOR (data);
+  GimpContext    *context = editor->context;
+  GimpToolPreset *preset;
+  GimpToolInfo   *tool_info;
+
+  preset    = GIMP_TOOL_PRESET (gimp_data_editor_get_data (editor));
+  tool_info = gimp_context_get_tool (gimp_get_user_context (context->gimp));
+
+  if (tool_info && preset)
+    {
+      GimpToolInfo *preset_tool;
+
+      preset_tool =  gimp_context_get_tool (GIMP_CONTEXT (preset->tool_options));
+
+      if (tool_info != preset_tool)
+        {
+          gimp_message (context->gimp,
+                        G_OBJECT (editor), GIMP_MESSAGE_WARNING,
+                        _("Can't save '%s' tool options to an "
+                          "existing '%s' tool preset."),
+                        tool_info->blurb,
+                        preset_tool->blurb);
+          return;
+        }
+
+      gimp_config_sync (G_OBJECT (tool_info->tool_options),
+                        G_OBJECT (preset->tool_options), 0);
+    }
+}
+
+void
+tool_preset_editor_restore_cmd_callback (GtkAction *action,
+                                         gpointer   data)
+{
+  GimpDataEditor *editor  = GIMP_DATA_EDITOR (data);
+  GimpContext    *context = editor->context;
+  GimpToolPreset *preset;
+
+  preset = GIMP_TOOL_PRESET (gimp_data_editor_get_data (editor));
+
+  if (preset)
+    gimp_context_tool_preset_changed (gimp_get_user_context (context->gimp));
+}

app/actions/tool-preset-editor-commands.h

@@ -0,0 +1,28 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __TOOL_PRESET_EDITOR_COMMANDS_H__
+#define __TOOL_PRESET_EDITOR_COMMANDS_H__
+
+
+void   tool_preset_editor_save_cmd_callback    (GtkAction *action,
+                                                gpointer   data);
+void   tool_preset_editor_restore_cmd_callback (GtkAction *action,
+                                                gpointer   data);
+
+
+#endif /* __TOOL_PRESET_EDITOR_COMMANDS_H__ */

app/actions/tool-presets-actions.c

@@ -35,6 +35,7 @@
 #include "actions.h"
 #include "data-commands.h"
 #include "tool-presets-actions.h"
+#include "tool-presets-commands.h"
 
 #include "gimp-intl.h"
 
@@ -63,12 +64,25 @@ static const GimpActionEntry tool_presets_actions[] =
     G_CALLBACK (data_copy_location_cmd_callback),
     GIMP_HELP_TOOL_PRESET_COPY_LOCATION },
 
-  { "tool-presets-show-in-file-manager", "gtk-directory",
+  { "tool-presets-show-in-file-manager", GIMP_STOCK_FILE_MANAGER,
     NC_("tool-presets-action", "Show in _File Manager"), NULL,
     NC_("tool-presets-action", "Show tool preset file location in the file manager"),
     G_CALLBACK (data_show_in_file_manager_cmd_callback),
     GIMP_HELP_TOOL_PRESET_SHOW_IN_FILE_MANAGER },
 
+  { "tool-presets-save", "document-save",
+    NC_("tool-presets-action", "_Save Tool Options to Preset"), NULL,
+    NC_("tool-presets-action", "Save the active tool options to this "
+        "tool preset"),
+    G_CALLBACK (tool_presets_save_cmd_callback),
+    GIMP_HELP_TOOL_PRESET_SAVE },
+
+  { "tool-presets-restore", "document-revert",
+    NC_("tool-presets-action", "_Restore Tool Preset"), NULL,
+    NC_("tool-presets-action", "Restore this tool preset"),
+    G_CALLBACK (tool_presets_restore_cmd_callback),
+    GIMP_HELP_TOOL_PRESET_RESTORE },
+
   { "tool-presets-delete", "edit-delete",
     NC_("tool-presets-action", "_Delete Tool Preset"), NULL,
     NC_("tool-presets-action", "Delete this tool preset"),
@@ -133,6 +147,8 @@ tool_presets_actions_update (GimpActionGroup *group,
   SET_SENSITIVE ("tool-presets-duplicate",            tool_preset && GIMP_DATA_GET_CLASS (data)->duplicate);
   SET_SENSITIVE ("tool-presets-copy-location",        file);
   SET_SENSITIVE ("tool-presets-show-in-file-manager", file);
+  SET_SENSITIVE ("tool-presets-save",                 tool_preset);
+  SET_SENSITIVE ("tool-presets-restore",              tool_preset);
   SET_SENSITIVE ("tool-presets-delete",               tool_preset && gimp_data_is_deletable (data));
 
 #undef SET_SENSITIVE

app/actions/tool-presets-commands.c

@@ -0,0 +1,93 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <gegl.h>
+#include <gtk/gtk.h>
+
+#include "libgimpconfig/gimpconfig.h"
+#include "libgimpwidgets/gimpwidgets.h"
+
+#include "actions-types.h"
+
+#include "core/gimp.h"
+#include "core/gimpcontext.h"
+#include "core/gimptoolinfo.h"
+#include "core/gimptoolpreset.h"
+
+#include "widgets/gimpcontainereditor.h"
+#include "widgets/gimpcontainerview.h"
+
+#include "tool-presets-commands.h"
+
+#include "gimp-intl.h"
+
+
+/*  public functions  */
+
+void
+tool_presets_save_cmd_callback (GtkAction *action,
+                                gpointer   data)
+{
+  GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
+  GimpContext         *context;
+  GimpToolPreset      *preset;
+  GimpToolInfo        *tool_info;
+
+  context = gimp_container_view_get_context (editor->view);
+
+  preset    = gimp_context_get_tool_preset (context);
+  tool_info = gimp_context_get_tool (gimp_get_user_context (context->gimp));
+
+  if (tool_info && preset)
+    {
+      GimpToolInfo *preset_tool;
+
+      preset_tool =  gimp_context_get_tool (GIMP_CONTEXT (preset->tool_options));
+
+      if (tool_info != preset_tool)
+        {
+          gimp_message (context->gimp,
+                        G_OBJECT (editor), GIMP_MESSAGE_WARNING,
+                        _("Can't save '%s' tool options to an "
+                          "existing '%s' tool preset."),
+                        tool_info->blurb,
+                        preset_tool->blurb);
+          return;
+        }
+
+      gimp_config_sync (G_OBJECT (tool_info->tool_options),
+                        G_OBJECT (preset->tool_options), 0);
+    }
+}
+
+void
+tool_presets_restore_cmd_callback (GtkAction *action,
+                                   gpointer   data)
+{
+  GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
+  GimpContext         *context;
+  GimpToolPreset      *preset;
+
+  context = gimp_container_view_get_context (editor->view);
+
+  preset = gimp_context_get_tool_preset (context);
+
+  if (preset)
+    gimp_context_tool_preset_changed (gimp_get_user_context (context->gimp));
+}

app/actions/tool-presets-commands.h

@@ -0,0 +1,28 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __TOOL_PRESETS_COMMANDS_H__
+#define __TOOL_PRESETS_COMMANDS_H__
+
+
+void   tool_presets_save_cmd_callback    (GtkAction *action,
+                                          gpointer   data);
+void   tool_presets_restore_cmd_callback (GtkAction *action,
+                                          gpointer   data);
+
+
+#endif /* __TOOL_PRESETS_COMMANDS_H__ */

app/actions/tools-actions.c

@@ -26,8 +26,6 @@
 
 #include "actions-types.h"
 
-#include "config/gimpguiconfig.h" /* playground */
-
 #include "core/gimp.h"
 #include "core/gimpcontainer.h"
 #include "core/gimpcontext.h"
@@ -83,6 +81,14 @@ static const GimpEnumActionEntry tools_paintbrush_size_actions[] =
     NULL }
 };
 
+static const GimpEnumActionEntry tools_paintbrush_aspect_ratio_actions[] =
+{
+  { "tools-paintbrush-aspect-ratio-set", GIMP_STOCK_TOOL_PAINTBRUSH,
+    "Set Brush Aspect Ratio", NULL, NULL,
+    GIMP_ACTION_SELECT_SET, TRUE,
+    NULL }
+};
+
 static const GimpEnumActionEntry tools_paintbrush_angle_actions[] =
 {
   { "tools-paintbrush-angle-set", GIMP_STOCK_TOOL_PAINTBRUSH,
@@ -91,10 +97,26 @@ static const GimpEnumActionEntry tools_paintbrush_angle_actions[] =
     NULL }
 };
 
-static const GimpEnumActionEntry tools_paintbrush_aspect_ratio_actions[] =
+static const GimpEnumActionEntry tools_paintbrush_spacing_actions[] =
 {
-  { "tools-paintbrush-aspect-ratio-set", GIMP_STOCK_TOOL_PAINTBRUSH,
+  { "tools-paintbrush-spacing-set", GIMP_STOCK_TOOL_PAINTBRUSH,
-    "Set Brush Aspect Ratio", NULL, NULL,
+    "Set Brush Spacing", NULL, NULL,
+    GIMP_ACTION_SELECT_SET, TRUE,
+    NULL }
+};
+
+static const GimpEnumActionEntry tools_paintbrush_hardness_actions[] =
+{
+  { "tools-paintbrush-hardness-set", GIMP_STOCK_TOOL_PAINTBRUSH,
+    "Set Brush Hardness", NULL, NULL,
+    GIMP_ACTION_SELECT_SET, TRUE,
+    NULL }
+};
+
+static const GimpEnumActionEntry tools_paintbrush_force_actions[] =
+{
+  { "tools-paintbrush-force-set", GIMP_STOCK_TOOL_PAINTBRUSH,
+    "Set Brush Force", NULL, NULL,
     GIMP_ACTION_SELECT_SET, TRUE,
     NULL }
 };
@@ -187,15 +209,21 @@ static const GimpEnumActionEntry tools_airbrush_flow_actions[] =
     NULL }
 };
 
-#ifdef HAVE_LIBMYPAINT
 static const GimpEnumActionEntry tools_mybrush_radius_actions[] =
 {
-  { "tools-mybrush-radius-set", GIMP_STOCK_TOOL_MYBRUSH,
+  { "tools-mypaint-brush-radius-set", GIMP_STOCK_TOOL_MYPAINT_BRUSH,
     "Set MyPaint Brush Radius", NULL, NULL,
     GIMP_ACTION_SELECT_SET, TRUE,
     NULL }
 };
-#endif
+
+static const GimpEnumActionEntry tools_mybrush_hardness_actions[] =
+{
+  { "tools-mypaint-brush-hardness-set", GIMP_STOCK_TOOL_MYPAINT_BRUSH,
+    "Set MyPaint Brush Hardness", NULL, NULL,
+    GIMP_ACTION_SELECT_SET, TRUE,
+    NULL }
+};
 
 static const GimpEnumActionEntry tools_foreground_select_brush_size_actions[] =
 {
@@ -223,6 +251,15 @@ static const GimpEnumActionEntry tools_warp_effect_size_actions[] =
     NULL }
 };
 
+static const GimpEnumActionEntry tools_warp_effect_hardness_actions[] =
+{
+  { "tools-warp-effect-hardness-set",
+    GIMP_STOCK_TOOL_WARP,
+    "Set Warp Effect Hardness", NULL, NULL,
+    GIMP_ACTION_SELECT_SET, TRUE,
+    NULL }
+};
+
 static const GimpEnumActionEntry tools_opacity_actions[] =
 {
   { "tools-opacity-set", GIMP_STOCK_TOOL_OPTIONS,
@@ -399,6 +436,138 @@ static const GimpEnumActionEntry tools_angle_actions[] =
     NULL },
 };
 
+static const GimpEnumActionEntry tools_spacing_actions[] =
+{
+  { "tools-spacing-set", GIMP_STOCK_TOOL_OPTIONS,
+    "Set Spacing", NULL, NULL,
+    GIMP_ACTION_SELECT_SET, TRUE,
+    NULL },
+  { "tools-spacing-set-to-default", GIMP_STOCK_TOOL_OPTIONS,
+    "Set Spacing To Default Value", NULL, NULL,
+    GIMP_ACTION_SELECT_SET_TO_DEFAULT, FALSE,
+    NULL },
+  { "tools-spacing-minimum", GIMP_STOCK_TOOL_OPTIONS,
+    "Minimize Spacing", NULL, NULL,
+    GIMP_ACTION_SELECT_FIRST, FALSE,
+    NULL },
+  { "tools-spacing-maximum", GIMP_STOCK_TOOL_OPTIONS,
+    "Maximize Spacing", NULL, NULL,
+    GIMP_ACTION_SELECT_LAST, FALSE,
+    NULL },
+  { "tools-spacing-decrease", GIMP_STOCK_TOOL_OPTIONS,
+    "Decrease Spacing", NULL, NULL,
+    GIMP_ACTION_SELECT_PREVIOUS, FALSE,
+    NULL },
+  { "tools-spacing-increase", GIMP_STOCK_TOOL_OPTIONS,
+    "Increase Spacing", NULL, NULL,
+    GIMP_ACTION_SELECT_NEXT, FALSE,
+    NULL },
+  { "tools-spacing-decrease-skip", GIMP_STOCK_TOOL_OPTIONS,
+    "Decrease Spacing More", NULL, NULL,
+    GIMP_ACTION_SELECT_SKIP_PREVIOUS, FALSE,
+    NULL },
+  { "tools-spacing-increase-skip", GIMP_STOCK_TOOL_OPTIONS,
+    "Increase Spacing More", NULL, NULL,
+    GIMP_ACTION_SELECT_SKIP_NEXT, FALSE,
+    NULL },
+  { "tools-spacing-decrease-percent", GIMP_STOCK_TOOL_OPTIONS,
+    "Decrease Spacing Relative", NULL, NULL,
+    GIMP_ACTION_SELECT_PERCENT_PREVIOUS, FALSE,
+    NULL },
+  { "tools-spacing-increase-percent", GIMP_STOCK_TOOL_OPTIONS,
+    "Increase Spacing Relative", NULL, NULL,
+    GIMP_ACTION_SELECT_PERCENT_NEXT, FALSE,
+    NULL },
+};
+
+static const GimpEnumActionEntry tools_hardness_actions[] =
+{
+  { "tools-hardness-set", GIMP_STOCK_TOOL_OPTIONS,
+    "Set Hardness", NULL, NULL,
+    GIMP_ACTION_SELECT_SET, TRUE,
+    NULL },
+  { "tools-hardness-set-to-default", GIMP_STOCK_TOOL_OPTIONS,
+    "Set Hardness To Default Value", NULL, NULL,
+    GIMP_ACTION_SELECT_SET_TO_DEFAULT, FALSE,
+    NULL },
+  { "tools-hardness-minimum", GIMP_STOCK_TOOL_OPTIONS,
+    "Minimize Hardness", NULL, NULL,
+    GIMP_ACTION_SELECT_FIRST, FALSE,
+    NULL },
+  { "tools-hardness-maximum", GIMP_STOCK_TOOL_OPTIONS,
+    "Maximize Hardness", NULL, NULL,
+    GIMP_ACTION_SELECT_LAST, FALSE,
+    NULL },
+  { "tools-hardness-decrease", GIMP_STOCK_TOOL_OPTIONS,
+    "Decrease Hardness", NULL, NULL,
+    GIMP_ACTION_SELECT_PREVIOUS, FALSE,
+    NULL },
+  { "tools-hardness-increase", GIMP_STOCK_TOOL_OPTIONS,
+    "Increase Hardness", NULL, NULL,
+    GIMP_ACTION_SELECT_NEXT, FALSE,
+    NULL },
+  { "tools-hardness-decrease-skip", GIMP_STOCK_TOOL_OPTIONS,
+    "Decrease Hardness More", NULL, NULL,
+    GIMP_ACTION_SELECT_SKIP_PREVIOUS, FALSE,
+    NULL },
+  { "tools-hardness-increase-skip", GIMP_STOCK_TOOL_OPTIONS,
+    "Increase Hardness More", NULL, NULL,
+    GIMP_ACTION_SELECT_SKIP_NEXT, FALSE,
+    NULL },
+  { "tools-hardness-decrease-percent", GIMP_STOCK_TOOL_OPTIONS,
+    "Decrease Hardness Relative", NULL, NULL,
+    GIMP_ACTION_SELECT_PERCENT_PREVIOUS, FALSE,
+    NULL },
+  { "tools-hardness-increase-percent", GIMP_STOCK_TOOL_OPTIONS,
+    "Increase Hardness Relative", NULL, NULL,
+    GIMP_ACTION_SELECT_PERCENT_NEXT, FALSE,
+    NULL },
+};
+
+static const GimpEnumActionEntry tools_force_actions[] =
+{
+  { "tools-force-set", GIMP_STOCK_TOOL_OPTIONS,
+    "Set Force", NULL, NULL,
+    GIMP_ACTION_SELECT_SET, TRUE,
+    NULL },
+  { "tools-force-set-to-default", GIMP_STOCK_TOOL_OPTIONS,
+    "Set Force To Default Value", NULL, NULL,
+    GIMP_ACTION_SELECT_SET_TO_DEFAULT, FALSE,
+    NULL },
+  { "tools-force-minimum", GIMP_STOCK_TOOL_OPTIONS,
+    "Minimize Force", NULL, NULL,
+    GIMP_ACTION_SELECT_FIRST, FALSE,
+    NULL },
+  { "tools-force-maximum", GIMP_STOCK_TOOL_OPTIONS,
+    "Maximize Force", NULL, NULL,
+    GIMP_ACTION_SELECT_LAST, FALSE,
+    NULL },
+  { "tools-force-decrease", GIMP_STOCK_TOOL_OPTIONS,
+    "Decrease Force", NULL, NULL,
+    GIMP_ACTION_SELECT_PREVIOUS, FALSE,
+    NULL },
+  { "tools-force-increase", GIMP_STOCK_TOOL_OPTIONS,
+    "Increase Force", NULL, NULL,
+    GIMP_ACTION_SELECT_NEXT, FALSE,
+    NULL },
+  { "tools-force-decrease-skip", GIMP_STOCK_TOOL_OPTIONS,
+    "Decrease Force More", NULL, NULL,
+    GIMP_ACTION_SELECT_SKIP_PREVIOUS, FALSE,
+    NULL },
+  { "tools-force-increase-skip", GIMP_STOCK_TOOL_OPTIONS,
+    "Increase Force More", NULL, NULL,
+    GIMP_ACTION_SELECT_SKIP_NEXT, FALSE,
+    NULL },
+  { "tools-force-decrease-percent", GIMP_STOCK_TOOL_OPTIONS,
+    "Decrease Force Relative", NULL, NULL,
+    GIMP_ACTION_SELECT_PERCENT_PREVIOUS, FALSE,
+    NULL },
+  { "tools-force-increase-percent", GIMP_STOCK_TOOL_OPTIONS,
+    "Increase Force Relative", NULL, NULL,
+    GIMP_ACTION_SELECT_PERCENT_NEXT, FALSE,
+    NULL },
+};
+
 static const GimpEnumActionEntry tools_object_1_actions[] =
 {
   { "tools-object-1-set", GIMP_STOCK_TOOL_OPTIONS,
@@ -476,16 +645,26 @@ tools_actions_setup (GimpActionGroup *group)
                                       tools_paintbrush_size_actions,
                                       G_N_ELEMENTS (tools_paintbrush_size_actions),
                                       G_CALLBACK (tools_paintbrush_size_cmd_callback));
-
-  gimp_action_group_add_enum_actions (group, NULL,
-                                      tools_paintbrush_angle_actions,
-                                      G_N_ELEMENTS (tools_paintbrush_angle_actions),
-                                      G_CALLBACK (tools_paintbrush_angle_cmd_callback));
-
   gimp_action_group_add_enum_actions (group, NULL,
                                       tools_paintbrush_aspect_ratio_actions,
                                       G_N_ELEMENTS (tools_paintbrush_aspect_ratio_actions),
                                       G_CALLBACK (tools_paintbrush_aspect_ratio_cmd_callback));
+  gimp_action_group_add_enum_actions (group, NULL,
+                                      tools_paintbrush_angle_actions,
+                                      G_N_ELEMENTS (tools_paintbrush_angle_actions),
+                                      G_CALLBACK (tools_paintbrush_angle_cmd_callback));
+  gimp_action_group_add_enum_actions (group, NULL,
+                                      tools_paintbrush_spacing_actions,
+                                      G_N_ELEMENTS (tools_paintbrush_spacing_actions),
+                                      G_CALLBACK (tools_paintbrush_spacing_cmd_callback));
+  gimp_action_group_add_enum_actions (group, NULL,
+                                      tools_paintbrush_hardness_actions,
+                                      G_N_ELEMENTS (tools_paintbrush_hardness_actions),
+                                      G_CALLBACK (tools_paintbrush_hardness_cmd_callback));
+  gimp_action_group_add_enum_actions (group, NULL,
+                                      tools_paintbrush_force_actions,
+                                      G_N_ELEMENTS (tools_paintbrush_force_actions),
+                                      G_CALLBACK (tools_paintbrush_force_cmd_callback));
 
   gimp_action_group_add_enum_actions (group, NULL,
                                       tools_ink_blob_size_actions,
@@ -509,13 +688,14 @@ tools_actions_setup (GimpActionGroup *group)
                                       G_N_ELEMENTS (tools_airbrush_flow_actions),
                                       G_CALLBACK (tools_airbrush_flow_cmd_callback));
 
-#ifdef HAVE_LIBMYPAINT
+  gimp_action_group_add_enum_actions (group, NULL,
-  if (GIMP_GUI_CONFIG (group->gimp->config)->playground_mybrush_tool)
+                                      tools_mybrush_radius_actions,
-    gimp_action_group_add_enum_actions (group, NULL,
+                                      G_N_ELEMENTS (tools_mybrush_radius_actions),
-                                        tools_mybrush_radius_actions,
+                                      G_CALLBACK (tools_mybrush_radius_cmd_callback));
-                                        G_N_ELEMENTS (tools_mybrush_radius_actions),
+  gimp_action_group_add_enum_actions (group, NULL,
-                                        G_CALLBACK (tools_mybrush_radius_cmd_callback));
+                                      tools_mybrush_hardness_actions,
-#endif
+                                      G_N_ELEMENTS (tools_mybrush_hardness_actions),
+                                      G_CALLBACK (tools_mybrush_hardness_cmd_callback));
 
   gimp_action_group_add_enum_actions (group, NULL,
                                       tools_foreground_select_brush_size_actions,
@@ -531,6 +711,10 @@ tools_actions_setup (GimpActionGroup *group)
                                       tools_warp_effect_size_actions,
                                       G_N_ELEMENTS (tools_warp_effect_size_actions),
                                       G_CALLBACK (tools_warp_effect_size_cmd_callback));
+  gimp_action_group_add_enum_actions (group, NULL,
+                                      tools_warp_effect_hardness_actions,
+                                      G_N_ELEMENTS (tools_warp_effect_hardness_actions),
+                                      G_CALLBACK (tools_warp_effect_hardness_cmd_callback));
 
   gimp_action_group_add_enum_actions (group, NULL,
                                       tools_opacity_actions,
@@ -548,6 +732,18 @@ tools_actions_setup (GimpActionGroup *group)
                                       tools_angle_actions,
                                       G_N_ELEMENTS (tools_angle_actions),
                                       G_CALLBACK (tools_angle_cmd_callback));
+  gimp_action_group_add_enum_actions (group, NULL,
+                                      tools_spacing_actions,
+                                      G_N_ELEMENTS (tools_spacing_actions),
+                                      G_CALLBACK (tools_spacing_cmd_callback));
+  gimp_action_group_add_enum_actions (group, NULL,
+                                      tools_hardness_actions,
+                                      G_N_ELEMENTS (tools_hardness_actions),
+                                      G_CALLBACK (tools_hardness_cmd_callback));
+  gimp_action_group_add_enum_actions (group, NULL,
+                                      tools_force_actions,
+                                      G_N_ELEMENTS (tools_force_actions),
+                                      G_CALLBACK (tools_force_cmd_callback));
 
   gimp_action_group_add_enum_actions (group, NULL,
                                       tools_object_1_actions,

app/actions/tools-commands.c

@@ -22,6 +22,8 @@
 #include <gegl.h>
 #include <gtk/gtk.h>
 
+#include "libgimpmath/gimpmath.h"
+
 #include "actions-types.h"
 
 #include "core/gimp.h"
@@ -42,7 +44,7 @@
 #include "tools/gimpcoloroptions.h"
 #include "tools/gimpforegroundselectoptions.h"
 #include "tools/gimprectangleoptions.h"
-#include "tools/gimpimagemaptool.h"
+#include "tools/gimptool.h"
 #include "tools/gimptoolcontrol.h"
 #include "tools/gimptransformoptions.h"
 #include "tools/gimpwarpoptions.h"
@@ -189,6 +191,69 @@ tools_paintbrush_aspect_ratio_cmd_callback (GtkAction *action,
     }
 }
 
+void
+tools_paintbrush_spacing_cmd_callback (GtkAction *action,
+                                       gint       value,
+                                       gpointer   data)
+{
+  GimpContext  *context;
+  GimpToolInfo *tool_info;
+  return_if_no_context (context, data);
+
+  tool_info = gimp_context_get_tool (context);
+
+  if (tool_info && GIMP_IS_PAINT_OPTIONS (tool_info->tool_options))
+    {
+      action_select_property ((GimpActionSelectType) value,
+                              action_data_get_display (data),
+                              G_OBJECT (tool_info->tool_options),
+                              "brush-spacing",
+                              0.001, 0.01, 0.1, 0.1, FALSE);
+    }
+}
+
+void
+tools_paintbrush_hardness_cmd_callback (GtkAction *action,
+                                        gint       value,
+                                        gpointer   data)
+{
+  GimpContext  *context;
+  GimpToolInfo *tool_info;
+  return_if_no_context (context, data);
+
+  tool_info = gimp_context_get_tool (context);
+
+  if (tool_info && GIMP_IS_PAINT_OPTIONS (tool_info->tool_options))
+    {
+      action_select_property ((GimpActionSelectType) value,
+                              action_data_get_display (data),
+                              G_OBJECT (tool_info->tool_options),
+                              "brush-hardness",
+                              0.001, 0.01, 0.1, 0.1, FALSE);
+    }
+}
+
+void
+tools_paintbrush_force_cmd_callback (GtkAction *action,
+                                     gint       value,
+                                     gpointer   data)
+{
+  GimpContext  *context;
+  GimpToolInfo *tool_info;
+  return_if_no_context (context, data);
+
+  tool_info = gimp_context_get_tool (context);
+
+  if (tool_info && GIMP_IS_PAINT_OPTIONS (tool_info->tool_options))
+    {
+      action_select_property ((GimpActionSelectType) value,
+                              action_data_get_display (data),
+                              G_OBJECT (tool_info->tool_options),
+                              "brush-force",
+                              0.001, 0.01, 0.1, 0.1, FALSE);
+    }
+}
+
 void
 tools_ink_blob_size_cmd_callback (GtkAction *action,
                                   gint       value,
@@ -206,7 +271,7 @@ tools_ink_blob_size_cmd_callback (GtkAction *action,
                               action_data_get_display (data),
                               G_OBJECT (tool_info->tool_options),
                               "size",
-                              1.0, 1.0, 10.0, 0.1, FALSE);
+                              0.1, 1.0, 10.0, 0.1, FALSE);
     }
 }
 
@@ -248,7 +313,10 @@ tools_ink_blob_angle_cmd_callback (GtkAction *action,
                               action_data_get_display (data),
                               G_OBJECT (tool_info->tool_options),
                               "blob-angle",
-                              1.0, 1.0, 15.0, 0.1, TRUE);
+                              gimp_deg_to_rad (0.1),
+                              gimp_deg_to_rad (1.0),
+                              gimp_deg_to_rad (15.0),
+                              0.1, TRUE);
     }
 }
 
@@ -269,7 +337,7 @@ tools_airbrush_rate_cmd_callback (GtkAction *action,
                               action_data_get_display (data),
                               G_OBJECT (tool_info->tool_options),
                               "rate",
-                              0.1, 1.0, 15.0, 0.1, FALSE);
+                              0.1, 1.0, 10.0, 0.1, FALSE);
     }
 }
 
@@ -294,7 +362,6 @@ tools_airbrush_flow_cmd_callback (GtkAction *action,
     }
 }
 
-#ifdef HAVE_LIBMYPAINT
 void
 tools_mybrush_radius_cmd_callback (GtkAction *action,
                                    gint       value,
@@ -315,7 +382,27 @@ tools_mybrush_radius_cmd_callback (GtkAction *action,
                               0.1, 0.1, 0.5, 1.0, FALSE);
     }
 }
-#endif
+
+void
+tools_mybrush_hardness_cmd_callback (GtkAction *action,
+                                   gint       value,
+                                   gpointer   data)
+{
+  GimpContext  *context;
+  GimpToolInfo *tool_info;
+  return_if_no_context (context, data);
+
+  tool_info = gimp_context_get_tool (context);
+
+  if (tool_info && GIMP_IS_MYBRUSH_OPTIONS (tool_info->tool_options))
+    {
+      action_select_property ((GimpActionSelectType) value,
+                              action_data_get_display (data),
+                              G_OBJECT (tool_info->tool_options),
+                              "hardness",
+                              0.001, 0.01, 0.1, 1.0, FALSE);
+    }
+}
 
 void
 tools_fg_select_brush_size_cmd_callback (GtkAction *action,
@@ -380,6 +467,27 @@ tools_warp_effect_size_cmd_callback (GtkAction *action,
     }
 }
 
+void
+tools_warp_effect_hardness_cmd_callback (GtkAction *action,
+                                         gint       value,
+                                         gpointer   data)
+{
+  GimpContext  *context;
+  GimpToolInfo *tool_info;
+  return_if_no_context (context, data);
+
+  tool_info = gimp_context_get_tool (context);
+
+  if (tool_info && GIMP_IS_WARP_OPTIONS (tool_info->tool_options))
+    {
+      action_select_property ((GimpActionSelectType) value,
+                              action_data_get_display (data),
+                              G_OBJECT (tool_info->tool_options),
+                              "effect-hardness",
+                              0.001, 0.01, 0.1, 0.1, FALSE);
+    }
+}
+
 void
 tools_opacity_cmd_callback (GtkAction *action,
                             gint       value,
@@ -468,6 +576,72 @@ tools_angle_cmd_callback (GtkAction *action,
     }
 }
 
+void
+tools_spacing_cmd_callback (GtkAction *action,
+                            gint       value,
+                            gpointer   data)
+{
+  GimpContext *context;
+  GimpTool    *tool;
+  return_if_no_context (context, data);
+
+  tool = tool_manager_get_active (context->gimp);
+
+  if (tool)
+    {
+      const gchar *action_desc;
+
+      action_desc = gimp_tool_control_get_action_spacing (tool->control);
+
+      if (action_desc)
+        tools_activate_enum_action (action_desc, value);
+    }
+}
+
+void
+tools_hardness_cmd_callback (GtkAction *action,
+                             gint       value,
+                             gpointer   data)
+{
+  GimpContext *context;
+  GimpTool    *tool;
+  return_if_no_context (context, data);
+
+  tool = tool_manager_get_active (context->gimp);
+
+  if (tool)
+    {
+      const gchar *action_desc;
+
+      action_desc = gimp_tool_control_get_action_hardness (tool->control);
+
+      if (action_desc)
+        tools_activate_enum_action (action_desc, value);
+    }
+}
+
+void
+tools_force_cmd_callback (GtkAction *action,
+                          gint       value,
+                          gpointer   data)
+{
+  GimpContext *context;
+  GimpTool    *tool;
+  return_if_no_context (context, data);
+
+  tool = tool_manager_get_active (context->gimp);
+
+  if (tool)
+    {
+      const gchar *action_desc;
+
+      action_desc = gimp_tool_control_get_action_force (tool->control);
+
+      if (action_desc)
+        tools_activate_enum_action (action_desc, value);
+    }
+}
+
 void
 tools_object_1_cmd_callback (GtkAction *action,
                              gint       value,

app/actions/tools-commands.h

@@ -36,6 +36,15 @@ void   tools_paintbrush_angle_cmd_callback          (GtkAction   *action,
 void   tools_paintbrush_aspect_ratio_cmd_callback   (GtkAction   *action,
                                                      gint         value,
                                                      gpointer     data);
+void   tools_paintbrush_spacing_cmd_callback        (GtkAction   *action,
+                                                     gint         value,
+                                                     gpointer     data);
+void   tools_paintbrush_hardness_cmd_callback       (GtkAction   *action,
+                                                     gint         value,
+                                                     gpointer     data);
+void   tools_paintbrush_force_cmd_callback          (GtkAction   *action,
+                                                     gint         value,
+                                                     gpointer     data);
 
 void   tools_ink_blob_size_cmd_callback             (GtkAction   *action,
                                                      gint         value,
@@ -54,11 +63,12 @@ void   tools_airbrush_flow_cmd_callback             (GtkAction   *action,
                                                      gint         value,
                                                      gpointer     data);
 
-#ifdef HAVE_LIBMYPAINT
 void   tools_mybrush_radius_cmd_callback            (GtkAction   *action,
                                                      gint         value,
                                                      gpointer     data);
-#endif
+void   tools_mybrush_hardness_cmd_callback          (GtkAction   *action,
+                                                     gint         value,
+                                                     gpointer     data);
 
 void   tools_fg_select_brush_size_cmd_callback      (GtkAction   *action,
                                                      gint         value,
@@ -71,6 +81,9 @@ void   tools_transform_preview_opacity_cmd_callback (GtkAction   *action,
 void   tools_warp_effect_size_cmd_callback          (GtkAction   *action,
                                                      gint         value,
                                                      gpointer     data);
+void   tools_warp_effect_hardness_cmd_callback      (GtkAction   *action,
+                                                     gint         value,
+                                                     gpointer     data);
 
 void   tools_opacity_cmd_callback                   (GtkAction   *action,
                                                      gint         value,
@@ -84,6 +97,15 @@ void   tools_aspect_cmd_callback                    (GtkAction   *action,
 void   tools_angle_cmd_callback                     (GtkAction   *action,
                                                      gint         value,
                                                      gpointer     data);
+void   tools_spacing_cmd_callback                   (GtkAction   *action,
+                                                     gint         value,
+                                                     gpointer     data);
+void   tools_hardness_cmd_callback                  (GtkAction   *action,
+                                                     gint         value,
+                                                     gpointer     data);
+void   tools_force_cmd_callback                     (GtkAction   *action,
+                                                     gint         value,
+                                                     gpointer     data);
 
 void   tools_object_1_cmd_callback                  (GtkAction   *action,
                                                      gint         value,

app/actions/vectors-actions.c

@@ -30,8 +30,10 @@
 
 #include "widgets/gimpactiongroup.h"
 #include "widgets/gimphelp-ids.h"
+#include "widgets/gimpwidgets-utils.h"
 
 #include "actions.h"
+#include "items-actions.h"
 #include "vectors-actions.h"
 #include "vectors-commands.h"
 
@@ -44,6 +46,10 @@ static const GimpActionEntry vectors_actions[] =
     NC_("vectors-action", "Paths Menu"), NULL, NULL, NULL,
     GIMP_HELP_PATH_DIALOG },
 
+  { "vectors-color-tag-menu", GIMP_STOCK_CLOSE /* abused */,
+    NC_("vectors-action", "Color Tag"), NULL, NULL, NULL,
+    GIMP_HELP_PATH_COLOR_TAG },
+
   { "vectors-path-tool", GIMP_STOCK_TOOL_PATH,
     NC_("vectors-action", "Path _Tool"), NULL, NULL,
     G_CALLBACK (vectors_vectors_tool_cmd_callback),
@@ -108,6 +114,18 @@ static const GimpActionEntry vectors_actions[] =
     G_CALLBACK (vectors_lower_to_bottom_cmd_callback),
     GIMP_HELP_PATH_LOWER_TO_BOTTOM },
 
+  { "vectors-fill", GIMP_STOCK_TOOL_BUCKET_FILL,
+    NC_("vectors-action", "Fill Path..."), NULL,
+    NC_("vectors-action", "Fill the path"),
+    G_CALLBACK (vectors_fill_cmd_callback),
+    GIMP_HELP_PATH_FILL },
+
+  { "vectors-fill-last-values", GIMP_STOCK_TOOL_BUCKET_FILL,
+    NC_("vectors-action", "Fill Path"), NULL,
+    NC_("vectors-action", "Fill the path with last values"),
+    G_CALLBACK (vectors_fill_last_vals_cmd_callback),
+    GIMP_HELP_PATH_FILL },
+
   { "vectors-stroke", GIMP_STOCK_PATH_STROKE,
     NC_("vectors-action", "Stro_ke Path..."), NULL,
     NC_("vectors-action", "Paint along the path"),
@@ -168,6 +186,63 @@ static const GimpToggleActionEntry vectors_toggle_actions[] =
     GIMP_HELP_PATH_LOCK_POSITION }
 };
 
+static const GimpEnumActionEntry vectors_color_tag_actions[] =
+{
+  { "vectors-color-tag-none", GIMP_STOCK_CLOSE /* abused */,
+    NC_("vectors-action", "None"), NULL,
+    NC_("vectors-action", "Clear color tag"),
+    GIMP_COLOR_TAG_NONE, FALSE,
+    GIMP_HELP_PATH_COLOR_TAG },
+
+  { "vectors-color-tag-blue", NULL,
+    NC_("vectors-action", "Blue"), NULL,
+    NC_("vectors-action", "Set color tag to blue"),
+    GIMP_COLOR_TAG_BLUE, FALSE,
+    GIMP_HELP_PATH_COLOR_TAG },
+
+  { "vectors-color-tag-green", NULL,
+    NC_("vectors-action", "Green"), NULL,
+    NC_("vectors-action", "Set color tag to green"),
+    GIMP_COLOR_TAG_GREEN, FALSE,
+    GIMP_HELP_PATH_COLOR_TAG },
+
+  { "vectors-color-tag-yellow", NULL,
+    NC_("vectors-action", "Yellow"), NULL,
+    NC_("vectors-action", "Set color tag to yellow"),
+    GIMP_COLOR_TAG_YELLOW, FALSE,
+    GIMP_HELP_PATH_COLOR_TAG },
+
+  { "vectors-color-tag-orange", NULL,
+    NC_("vectors-action", "Orange"), NULL,
+    NC_("vectors-action", "Set color tag to orange"),
+    GIMP_COLOR_TAG_ORANGE, FALSE,
+    GIMP_HELP_PATH_COLOR_TAG },
+
+  { "vectors-color-tag-brown", NULL,
+    NC_("vectors-action", "Brown"), NULL,
+    NC_("vectors-action", "Set color tag to brown"),
+    GIMP_COLOR_TAG_BROWN, FALSE,
+    GIMP_HELP_PATH_COLOR_TAG },
+
+  { "vectors-color-tag-red", NULL,
+    NC_("vectors-action", "Red"), NULL,
+    NC_("vectors-action", "Set color tag to red"),
+    GIMP_COLOR_TAG_RED, FALSE,
+    GIMP_HELP_PATH_COLOR_TAG },
+
+  { "vectors-color-tag-violet", NULL,
+    NC_("vectors-action", "Violet"), NULL,
+    NC_("vectors-action", "Set color tag to violet"),
+    GIMP_COLOR_TAG_VIOLET, FALSE,
+    GIMP_HELP_PATH_COLOR_TAG },
+
+  { "vectors-color-tag-gray", NULL,
+    NC_("vectors-action", "Gray"), NULL,
+    NC_("vectors-action", "Set color tag to gray"),
+    GIMP_COLOR_TAG_GRAY, FALSE,
+    GIMP_HELP_PATH_COLOR_TAG }
+};
+
 static const GimpEnumActionEntry vectors_to_selection_actions[] =
 {
   { "vectors-selection-replace", GIMP_STOCK_SELECTION_REPLACE,
@@ -234,6 +309,11 @@ vectors_actions_setup (GimpActionGroup *group)
                                         vectors_toggle_actions,
                                         G_N_ELEMENTS (vectors_toggle_actions));
 
+  gimp_action_group_add_enum_actions (group, "vectors-action",
+                                      vectors_color_tag_actions,
+                                      G_N_ELEMENTS (vectors_color_tag_actions),
+                                      G_CALLBACK (vectors_color_tag_cmd_callback));
+
   gimp_action_group_add_enum_actions (group, "vectors-action",
                                       vectors_to_selection_actions,
                                       G_N_ELEMENTS (vectors_to_selection_actions),
@@ -243,27 +323,23 @@ vectors_actions_setup (GimpActionGroup *group)
                                       vectors_selection_to_vectors_actions,
                                       G_N_ELEMENTS (vectors_selection_to_vectors_actions),
                                       G_CALLBACK (vectors_selection_to_vectors_cmd_callback));
+
+  items_actions_setup (group, "vectors");
 }
 
 void
 vectors_actions_update (GimpActionGroup *group,
                         gpointer         data)
 {
-  GimpImage    *image        = action_data_get_image (data);
+  GimpImage    *image         = action_data_get_image (data);
-  GimpVectors  *vectors      = NULL;
+  GimpVectors  *vectors       = NULL;
-  GimpDrawable *drawable     = NULL;
+  GimpDrawable *drawable      = NULL;
-  gint          n_vectors    = 0;
+  gint          n_vectors     = 0;
-  gboolean      mask_empty   = TRUE;
+  gboolean      mask_empty    = TRUE;
-  gboolean      visible      = FALSE;
+  gboolean      dr_writable   = FALSE;
-  gboolean      linked       = FALSE;
+  gboolean      dr_children   = FALSE;
-  gboolean      locked       = FALSE;
+  GList        *next          = NULL;
-  gboolean      can_lock     = FALSE;
+  GList        *prev          = NULL;
-  gboolean      locked_pos   = FALSE;
-  gboolean      can_lock_pos = FALSE;
-  gboolean      dr_writable  = FALSE;
-  gboolean      dr_children  = FALSE;
-  GList        *next         = NULL;
-  GList        *prev         = NULL;
 
   if (image)
     {
@@ -274,17 +350,10 @@ vectors_actions_update (GimpActionGroup *group,
 
       if (vectors)
         {
-          GimpItem *item = GIMP_ITEM (vectors);
+          GList *vectors_list;
-          GList    *vectors_list;
+          GList *list;
-          GList    *list;
 
-          visible      = gimp_item_get_visible (item);
+          vectors_list = gimp_item_get_container_iter (GIMP_ITEM (vectors));
-          linked       = gimp_item_get_linked (item);
-          locked       = gimp_item_get_lock_content (item);
-          can_lock     = gimp_item_can_lock_content (item);
-          locked_pos   = gimp_item_get_lock_position (item);
-          can_lock_pos = gimp_item_can_lock_position (item);
-          vectors_list = gimp_item_get_container_iter (item);
 
           list = g_list_find (vectors_list, vectors);
 
@@ -299,11 +368,9 @@ vectors_actions_update (GimpActionGroup *group,
 
       if (drawable)
         {
-          GimpItem *item = GIMP_ITEM (drawable);
+          dr_writable = ! gimp_item_is_content_locked (GIMP_ITEM (drawable));
 
-          dr_writable = ! gimp_item_is_content_locked (item);
+          if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable)))
-
-          if (gimp_viewable_get_children (GIMP_VIEWABLE (item)))
             dr_children = TRUE;
         }
     }
@@ -332,19 +399,15 @@ vectors_actions_update (GimpActionGroup *group,
   SET_SENSITIVE ("vectors-export", vectors);
   SET_SENSITIVE ("vectors-import", image);
 
-  SET_SENSITIVE ("vectors-visible",       vectors);
-  SET_SENSITIVE ("vectors-linked",        vectors);
-  SET_SENSITIVE ("vectors-lock-content",  can_lock);
-  SET_SENSITIVE ("vectors-lock-position", can_lock_pos);
-
-  SET_ACTIVE ("vectors-visible",       visible);
-  SET_ACTIVE ("vectors-linked",        linked);
-  SET_ACTIVE ("vectors-lock-content",  locked);
-  SET_ACTIVE ("vectors-lock-position", locked_pos);
-
   SET_SENSITIVE ("vectors-selection-to-vectors",          image && !mask_empty);
   SET_SENSITIVE ("vectors-selection-to-vectors-short",    image && !mask_empty);
   SET_SENSITIVE ("vectors-selection-to-vectors-advanced", image && !mask_empty);
+  SET_SENSITIVE ("vectors-fill",                          vectors &&
+                                                          dr_writable &&
+                                                          !dr_children);
+  SET_SENSITIVE ("vectors-fill-last-values",              vectors &&
+                                                          dr_writable &&
+                                                          !dr_children);
   SET_SENSITIVE ("vectors-stroke",                        vectors &&
                                                           dr_writable &&
                                                           !dr_children);
@@ -360,4 +423,6 @@ vectors_actions_update (GimpActionGroup *group,
 
 #undef SET_SENSITIVE
 #undef SET_ACTIVE
+
+  items_actions_update (group, "vectors", GIMP_ITEM (vectors));
 }

app/actions/vectors-commands.c

@@ -23,10 +23,13 @@
 #include <gtk/gtk.h>
 
 #include "libgimpbase/gimpbase.h"
+#include "libgimpconfig/gimpconfig.h"
 #include "libgimpwidgets/gimpwidgets.h"
 
 #include "actions-types.h"
 
+#include "config/gimpdialogconfig.h"
+
 #include "core/gimp.h"
 #include "core/gimp-utils.h"
 #include "core/gimpchannel.h"
@@ -34,10 +37,8 @@
 #include "core/gimpimage.h"
 #include "core/gimpimage-merge.h"
 #include "core/gimpimage-undo.h"
-#include "core/gimpitemundo.h"
 #include "core/gimpparamspecs.h"
 #include "core/gimpprogress.h"
-#include "core/gimpstrokeoptions.h"
 #include "core/gimptoolinfo.h"
 
 #include "pdb/gimppdb.h"
@@ -56,12 +57,13 @@
 #include "tools/gimpvectortool.h"
 #include "tools/tool_manager.h"
 
-#include "dialogs/stroke-dialog.h"
+#include "dialogs/dialogs.h"
 #include "dialogs/vectors-export-dialog.h"
 #include "dialogs/vectors-import-dialog.h"
 #include "dialogs/vectors-options-dialog.h"
 
 #include "actions.h"
+#include "items-commands.h"
 #include "vectors-commands.h"
 
 #include "gimp-intl.h"
@@ -69,26 +71,41 @@
 
 /*  local function prototypes  */
 
-static void   vectors_new_vectors_response  (GtkWidget            *widget,
+static void   vectors_new_callback             (GtkWidget    *dialog,
-                                             gint                  response_id,
+                                                GimpImage    *image,
-                                             VectorsOptionsDialog *options);
+                                                GimpVectors  *vectors,
-static void   vectors_edit_vectors_response (GtkWidget            *widget,
+                                                GimpContext  *context,
-                                             gint                  response_id,
+                                                const gchar  *vectors_name,
-                                             VectorsOptionsDialog *options);
+                                                gboolean      vectors_visible,
-static void   vectors_import_response       (GtkWidget            *widget,
+                                                gboolean      vectors_linked,
-                                             gint                  response_id,
+                                                GimpColorTag  vectors_color_tag,
-                                             VectorsImportDialog  *dialog);
+                                                gboolean      vectors_lock_content,
-static void   vectors_export_response       (GtkWidget            *widget,
+                                                gboolean      vectors_lock_position,
-                                             gint                  response_id,
+                                                gpointer      user_data);
-                                             VectorsExportDialog  *dialog);
+static void   vectors_edit_attributes_callback (GtkWidget    *dialog,
-
+                                                GimpImage    *image,
-
+                                                GimpVectors  *vectors,
-/*  private variables  */
+                                                GimpContext  *context,
-
+                                                const gchar  *vectors_name,
-static gchar    *vectors_name               = NULL;
+                                                gboolean      vectors_visible,
-static gboolean  vectors_import_merge       = FALSE;
+                                                gboolean      vectors_linked,
-static gboolean  vectors_import_scale       = FALSE;
+                                                GimpColorTag  vectors_color_tag,
-static gboolean  vectors_export_active_only = TRUE;
+                                                gboolean      vectors_lock_content,
+                                                gboolean      vectors_lock_position,
+                                                gpointer      user_data);
+static void   vectors_import_callback          (GtkWidget    *dialog,
+                                                GimpImage    *image,
+                                                GFile        *file,
+                                                GFile        *import_folder,
+                                                gboolean      merge_vectors,
+                                                gboolean      scale_vectors,
+                                                gpointer      user_data);
+static void   vectors_export_callback          (GtkWidget    *dialog,
+                                                GimpImage    *image,
+                                                GFile        *file,
+                                                GFile        *export_folder,
+                                                gboolean      active_only,
+                                                gpointer      user_data);
 
 
 /*  public functions  */
@@ -124,71 +141,99 @@ void
 vectors_edit_attributes_cmd_callback (GtkAction *action,
                                       gpointer   data)
 {
-  VectorsOptionsDialog *options;
+  GimpImage   *image;
-  GimpImage            *image;
+  GimpVectors *vectors;
-  GimpVectors          *vectors;
+  GtkWidget   *widget;
-  GtkWidget            *widget;
+  GtkWidget   *dialog;
   return_if_no_vectors (image, vectors, data);
   return_if_no_widget (widget, data);
 
-  options = vectors_options_dialog_new (image, vectors,
+#define EDIT_DIALOG_KEY "gimp-vectors-edit-attributes-dialog"
-                                        action_data_get_context (data),
-                                        widget,
-                                        gimp_object_get_name (vectors),
-                                        _("Path Attributes"),
-                                        "gimp-vectors-edit",
-                                        "gtk-edit",
-                                        _("Edit Path Attributes"),
-                                        GIMP_HELP_PATH_EDIT);
 
-  g_signal_connect (options->dialog, "response",
+  dialog = dialogs_get_dialog (G_OBJECT (vectors), EDIT_DIALOG_KEY);
-                    G_CALLBACK (vectors_edit_vectors_response),
-                    options);
 
-  gtk_widget_show (options->dialog);
+  if (! dialog)
+    {
+      GimpItem *item = GIMP_ITEM (vectors);
+
+      dialog = vectors_options_dialog_new (image, vectors,
+                                           action_data_get_context (data),
+                                           widget,
+                                           _("Path Attributes"),
+                                           "gimp-vectors-edit",
+                                           "gtk-edit",
+                                           _("Edit Path Attributes"),
+                                           GIMP_HELP_PATH_EDIT,
+                                           gimp_object_get_name (vectors),
+                                           gimp_item_get_visible (item),
+                                           gimp_item_get_linked (item),
+                                           gimp_item_get_color_tag (item),
+                                           gimp_item_get_lock_content (item),
+                                           gimp_item_get_lock_position (item),
+                                           vectors_edit_attributes_callback,
+                                           NULL);
+
+      dialogs_attach_dialog (G_OBJECT (vectors), EDIT_DIALOG_KEY, dialog);
+    }
+
+  gtk_window_present (GTK_WINDOW (dialog));
 }
 
 void
 vectors_new_cmd_callback (GtkAction *action,
                           gpointer   data)
 {
-  VectorsOptionsDialog *options;
+  GimpImage *image;
-  GimpImage            *image;
+  GtkWidget *widget;
-  GtkWidget            *widget;
+  GtkWidget *dialog;
   return_if_no_image (image, data);
   return_if_no_widget (widget, data);
 
-  options = vectors_options_dialog_new (image, NULL,
+#define NEW_DIALOG_KEY "gimp-vectors-new-dialog"
-                                        action_data_get_context (data),
-                                        widget,
-                                        vectors_name ? vectors_name :
-                                        _("Path"),
-                                        _("New Path"),
-                                        "gimp-vectors-new",
-                                        GIMP_STOCK_PATH,
-                                        _("New Path Options"),
-                                        GIMP_HELP_PATH_NEW);
 
-  g_signal_connect (options->dialog, "response",
+  dialog = dialogs_get_dialog (G_OBJECT (image), NEW_DIALOG_KEY);
-                    G_CALLBACK (vectors_new_vectors_response),
-                    options);
 
-  gtk_widget_show (options->dialog);
+  if (! dialog)
+    {
+      GimpDialogConfig *config = GIMP_DIALOG_CONFIG (image->gimp->config);
+
+      dialog = vectors_options_dialog_new (image, NULL,
+                                           action_data_get_context (data),
+                                           widget,
+                                           _("New Path"),
+                                           "gimp-vectors-new",
+                                           GIMP_STOCK_PATH,
+                                           _("Create a New Path"),
+                                           GIMP_HELP_PATH_NEW,
+                                           config->vectors_new_name,
+                                           FALSE,
+                                           FALSE,
+                                           GIMP_COLOR_TAG_NONE,
+                                           FALSE,
+                                           FALSE,
+                                           vectors_new_callback,
+                                           NULL);
+
+      dialogs_attach_dialog (G_OBJECT (image), NEW_DIALOG_KEY, dialog);
+    }
+
+  gtk_window_present (GTK_WINDOW (dialog));
 }
 
 void
 vectors_new_last_vals_cmd_callback (GtkAction *action,
                                     gpointer   data)
 {
-  GimpImage   *image;
+  GimpImage        *image;
-  GimpVectors *new_vectors;
+  GimpVectors      *vectors;
+  GimpDialogConfig *config;
   return_if_no_image (image, data);
 
-  new_vectors = gimp_vectors_new (image, vectors_name);
+  config = GIMP_DIALOG_CONFIG (image->gimp->config);
 
-  gimp_image_add_vectors (image, new_vectors,
+  vectors = gimp_vectors_new (image, config->vectors_new_name);
+  gimp_image_add_vectors (image, vectors,
                           GIMP_IMAGE_ACTIVE_PARENT, -1, TRUE);
-
   gimp_image_flush (image);
 }
 
@@ -251,7 +296,6 @@ vectors_duplicate_cmd_callback (GtkAction *action,
 
   new_vectors = GIMP_VECTORS (gimp_item_duplicate (GIMP_ITEM (vectors),
                                                    G_TYPE_FROM_INSTANCE (vectors)));
-
   /*  use the actual parent here, not GIMP_IMAGE_ACTIVE_PARENT because
    *  the latter would add a duplicated group inside itself instead of
    *  above it
@@ -259,7 +303,6 @@ vectors_duplicate_cmd_callback (GtkAction *action,
   gimp_image_add_vectors (image, new_vectors,
                           gimp_vectors_get_parent (vectors), -1,
                           TRUE);
-
   gimp_image_flush (image);
 }
 
@@ -368,84 +411,64 @@ vectors_selection_to_vectors_cmd_callback (GtkAction *action,
     }
 }
 
+void
+vectors_fill_cmd_callback (GtkAction *action,
+                           gpointer   data)
+{
+  GimpImage   *image;
+  GimpVectors *vectors;
+  return_if_no_vectors (image, vectors, data);
+
+  items_fill_cmd_callback (action,
+                           image, GIMP_ITEM (vectors),
+                           "gimp-vectors-fill-dialog",
+                           _("Fill Path"),
+                           GIMP_STOCK_TOOL_BUCKET_FILL,
+                           GIMP_HELP_PATH_FILL,
+                           data);
+}
+
+void
+vectors_fill_last_vals_cmd_callback (GtkAction *action,
+                                     gpointer   data)
+{
+  GimpImage   *image;
+  GimpVectors *vectors;
+  return_if_no_vectors (image, vectors, data);
+
+  items_fill_last_vals_cmd_callback (action,
+                                     image, GIMP_ITEM (vectors),
+                                     data);
+}
+
 void
 vectors_stroke_cmd_callback (GtkAction *action,
                              gpointer   data)
 {
-  GimpImage    *image;
+  GimpImage   *image;
-  GimpVectors  *vectors;
+  GimpVectors *vectors;
-  GimpDrawable *drawable;
-  GtkWidget    *widget;
-  GtkWidget    *dialog;
   return_if_no_vectors (image, vectors, data);
-  return_if_no_widget (widget, data);
 
-  drawable = gimp_image_get_active_drawable (image);
+  items_stroke_cmd_callback (action,
-
+                             image, GIMP_ITEM (vectors),
-  if (! drawable)
+                             "gimp-vectors-stroke-dialog",
-    {
+                             _("Stroke Path"),
-      gimp_message_literal (image->gimp,
+                             GIMP_STOCK_PATH_STROKE,
-                            G_OBJECT (widget), GIMP_MESSAGE_WARNING,
+                             GIMP_HELP_PATH_STROKE,
-                            _("There is no active layer or channel to stroke to."));
+                             data);
-      return;
-    }
-
-  dialog = stroke_dialog_new (GIMP_ITEM (vectors),
-                              action_data_get_context (data),
-                              _("Stroke Path"),
-                              GIMP_STOCK_PATH_STROKE,
-                              GIMP_HELP_PATH_STROKE,
-                              widget);
-  gtk_widget_show (dialog);
 }
 
 void
 vectors_stroke_last_vals_cmd_callback (GtkAction *action,
                                        gpointer   data)
 {
-  GimpImage         *image;
+  GimpImage   *image;
-  GimpVectors       *vectors;
+  GimpVectors *vectors;
-  GimpDrawable      *drawable;
-  GimpContext       *context;
-  GtkWidget         *widget;
-  GimpStrokeOptions *options;
-  GError            *error = NULL;
   return_if_no_vectors (image, vectors, data);
-  return_if_no_context (context, data);
-  return_if_no_widget (widget, data);
 
-  drawable = gimp_image_get_active_drawable (image);
+  items_stroke_last_vals_cmd_callback (action,
-
+                                       image, GIMP_ITEM (vectors),
-  if (! drawable)
+                                       data);
-    {
-      gimp_message_literal (image->gimp,
-                            G_OBJECT (widget), GIMP_MESSAGE_WARNING,
-                            _("There is no active layer or channel to stroke to."));
-      return;
-    }
-
-
-  options = g_object_get_data (G_OBJECT (image->gimp), "saved-stroke-options");
-
-  if (options)
-    g_object_ref (options);
-  else
-    options = gimp_stroke_options_new (image->gimp, context, TRUE);
-
-  if (! gimp_item_stroke (GIMP_ITEM (vectors),
-                          drawable, context, options, NULL,
-                          TRUE, NULL, &error))
-    {
-      gimp_message_literal (image->gimp, G_OBJECT (widget),
-                            GIMP_MESSAGE_WARNING, error->message);
-      g_clear_error (&error);
-    }
-  else
-    {
-      gimp_image_flush (image);
-    }
-
-  g_object_unref (options);
 }
 
 void
@@ -505,56 +528,75 @@ void
 vectors_export_cmd_callback (GtkAction *action,
                              gpointer   data)
 {
-  VectorsExportDialog *dialog;
+  GimpImage   *image;
-  GimpImage           *image;
+  GimpVectors *vectors;
-  GimpVectors         *vectors;
+  GtkWidget   *widget;
-  GtkWidget           *widget;
+  GtkWidget   *dialog;
-  const gchar         *folder;
   return_if_no_vectors (image, vectors, data);
   return_if_no_widget (widget, data);
 
-  dialog = vectors_export_dialog_new (image, widget,
+#define EXPORT_DIALOG_KEY "gimp-vectors-export-dialog"
-                                      vectors_export_active_only);
 
-  folder = g_object_get_data (G_OBJECT (image->gimp),
+  dialog = dialogs_get_dialog (G_OBJECT (image), EXPORT_DIALOG_KEY);
-                              "gimp-vectors-export-folder");
-  if (folder)
-    gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog->dialog),
-                                         folder);
 
-  g_signal_connect (dialog->dialog, "response",
+  if (! dialog)
-                    G_CALLBACK (vectors_export_response),
+    {
-                    dialog);
+      GimpDialogConfig *config = GIMP_DIALOG_CONFIG (image->gimp->config);
+      GFile            *folder = NULL;
 
-  gtk_widget_show (dialog->dialog);
+      if (config->vectors_export_path)
+        folder = gimp_file_new_for_config_path (config->vectors_export_path,
+                                                NULL);
+
+      dialog = vectors_export_dialog_new (image, widget,
+                                          folder,
+                                          config->vectors_export_active_only,
+                                          vectors_export_callback,
+                                          NULL);
+
+      if (folder)
+        g_object_unref (folder);
+
+      dialogs_attach_dialog (G_OBJECT (image), EXPORT_DIALOG_KEY, dialog);
+    }
+
+  gtk_window_present (GTK_WINDOW (dialog));
 }
 
 void
 vectors_import_cmd_callback (GtkAction *action,
                              gpointer   data)
 {
-  VectorsImportDialog *dialog;
+  GimpImage *image;
-  GimpImage           *image;
+  GtkWidget *widget;
-  GtkWidget           *widget;
+  GtkWidget *dialog;
-  const gchar         *folder;
   return_if_no_image (image, data);
   return_if_no_widget (widget, data);
 
-  dialog = vectors_import_dialog_new (image, widget,
+#define IMPORT_DIALOG_KEY "gimp-vectors-import-dialog"
-                                      vectors_import_merge,
-                                      vectors_import_scale);
 
-  folder = g_object_get_data (G_OBJECT (image->gimp),
+  dialog = dialogs_get_dialog (G_OBJECT (image), IMPORT_DIALOG_KEY);
-                              "gimp-vectors-import-folder");
-  if (folder)
-    gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog->dialog),
-                                         folder);
 
-  g_signal_connect (dialog->dialog, "response",
+  if (! dialog)
-                    G_CALLBACK (vectors_import_response),
+    {
-                    dialog);
+      GimpDialogConfig *config = GIMP_DIALOG_CONFIG (image->gimp->config);
+      GFile            *folder = NULL;
 
-  gtk_widget_show (dialog->dialog);
+      if (config->vectors_import_path)
+        folder = gimp_file_new_for_config_path (config->vectors_import_path,
+                                                NULL);
+
+      dialog = vectors_import_dialog_new (image, widget,
+                                          folder,
+                                          config->vectors_import_merge,
+                                          config->vectors_import_scale,
+                                          vectors_import_callback,
+                                          NULL);
+
+      dialogs_attach_dialog (G_OBJECT (image), IMPORT_DIALOG_KEY, dialog);
+    }
+
+  gtk_window_present (GTK_WINDOW (dialog));
 }
 
 void
@@ -563,25 +605,9 @@ vectors_visible_cmd_callback (GtkAction *action,
 {
   GimpImage   *image;
   GimpVectors *vectors;
-  gboolean     visible;
   return_if_no_vectors (image, vectors, data);
 
-  visible = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+  items_visible_cmd_callback (action, image, GIMP_ITEM (vectors));
-
-  if (visible != gimp_item_get_visible (GIMP_ITEM (vectors)))
-    {
-      GimpUndo *undo;
-      gboolean  push_undo = TRUE;
-
-      undo = gimp_image_undo_can_compress (image, GIMP_TYPE_ITEM_UNDO,
-                                           GIMP_UNDO_ITEM_VISIBILITY);
-
-      if (undo && GIMP_ITEM_UNDO (undo)->item == GIMP_ITEM (vectors))
-        push_undo = FALSE;
-
-      gimp_item_set_visible (GIMP_ITEM (vectors), visible, push_undo);
-      gimp_image_flush (image);
-    }
 }
 
 void
@@ -590,25 +616,9 @@ vectors_linked_cmd_callback (GtkAction *action,
 {
   GimpImage   *image;
   GimpVectors *vectors;
-  gboolean     linked;
   return_if_no_vectors (image, vectors, data);
 
-  linked = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+  items_linked_cmd_callback (action, image, GIMP_ITEM (vectors));
-
-  if (linked != gimp_item_get_linked (GIMP_ITEM (vectors)))
-    {
-      GimpUndo *undo;
-      gboolean  push_undo = TRUE;
-
-      undo = gimp_image_undo_can_compress (image, GIMP_TYPE_ITEM_UNDO,
-                                           GIMP_UNDO_ITEM_LINKED);
-
-      if (undo && GIMP_ITEM_UNDO (undo)->item == GIMP_ITEM (vectors))
-        push_undo = FALSE;
-
-      gimp_item_set_linked (GIMP_ITEM (vectors), linked, push_undo);
-      gimp_image_flush (image);
-    }
 }
 
 void
@@ -617,29 +627,9 @@ vectors_lock_content_cmd_callback (GtkAction *action,
 {
   GimpImage   *image;
   GimpVectors *vectors;
-  gboolean     locked;
   return_if_no_vectors (image, vectors, data);
 
-  locked = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+  items_lock_content_cmd_callback (action, image, GIMP_ITEM (vectors));
-
-  if (locked != gimp_item_get_lock_content (GIMP_ITEM (vectors)))
-    {
-#if 0
-      GimpUndo *undo;
-#endif
-      gboolean  push_undo = TRUE;
-
-#if 0
-      undo = gimp_image_undo_can_compress (image, GIMP_TYPE_ITEM_UNDO,
-                                           GIMP_UNDO_ITEM_LINKED);
-
-      if (undo && GIMP_ITEM_UNDO (undo)->item == GIMP_ITEM (vectors))
-        push_undo = FALSE;
-#endif
-
-      gimp_item_set_lock_content (GIMP_ITEM (vectors), locked, push_undo);
-      gimp_image_flush (image);
-    }
 }
 
 void
@@ -648,156 +638,192 @@ vectors_lock_position_cmd_callback (GtkAction *action,
 {
   GimpImage   *image;
   GimpVectors *vectors;
-  gboolean     locked;
   return_if_no_vectors (image, vectors, data);
 
-  locked = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+  items_lock_position_cmd_callback (action, image, GIMP_ITEM (vectors));
-
-  if (locked != gimp_item_get_lock_position (GIMP_ITEM (vectors)))
-    {
-      GimpUndo *undo;
-      gboolean  push_undo = TRUE;
-
-      undo = gimp_image_undo_can_compress (image, GIMP_TYPE_ITEM_UNDO,
-                                           GIMP_UNDO_ITEM_LOCK_POSITION);
-
-      if (undo && GIMP_ITEM_UNDO (undo)->item == GIMP_ITEM (vectors))
-        push_undo = FALSE;
-
-
-      gimp_item_set_lock_position (GIMP_ITEM (vectors), locked, push_undo);
-      gimp_image_flush (image);
-    }
 }
 
+void
+vectors_color_tag_cmd_callback (GtkAction *action,
+                                gint       value,
+                                gpointer   data)
+{
+  GimpImage   *image;
+  GimpVectors *vectors;
+  return_if_no_vectors (image, vectors, data);
+
+  items_color_tag_cmd_callback (action, image, GIMP_ITEM (vectors),
+                                (GimpColorTag) value);
+}
+
+
 /*  private functions  */
 
 static void
-vectors_new_vectors_response (GtkWidget            *widget,
+vectors_new_callback (GtkWidget    *dialog,
-                              gint                  response_id,
+                      GimpImage    *image,
-                              VectorsOptionsDialog *options)
+                      GimpVectors  *vectors,
+                      GimpContext  *context,
+                      const gchar  *vectors_name,
+                      gboolean      vectors_visible,
+                      gboolean      vectors_linked,
+                      GimpColorTag  vectors_color_tag,
+                      gboolean      vectors_lock_content,
+                      gboolean      vectors_lock_position,
+                      gpointer      user_data)
 {
-  if (response_id == GTK_RESPONSE_OK)
+  GimpDialogConfig *config = GIMP_DIALOG_CONFIG (image->gimp->config);
-    {
-      GimpVectors *new_vectors;
 
-      if (vectors_name)
+  g_object_set (config,
-        g_free (vectors_name);
+                "path-new-name", vectors_name,
+                NULL);
 
-      vectors_name =
+  vectors = gimp_vectors_new (image, config->vectors_new_name);
-        g_strdup (gtk_entry_get_text (GTK_ENTRY (options->name_entry)));
+  gimp_item_set_visible (GIMP_ITEM (vectors), vectors_visible, FALSE);
+  gimp_item_set_linked (GIMP_ITEM (vectors), vectors_linked, FALSE);
+  gimp_item_set_color_tag (GIMP_ITEM (vectors), vectors_color_tag, FALSE);
+  gimp_item_set_lock_content (GIMP_ITEM (vectors), vectors_lock_content, FALSE);
+  gimp_item_set_lock_position (GIMP_ITEM (vectors), vectors_lock_position, FALSE);
 
-      new_vectors = gimp_vectors_new (options->image, vectors_name);
+  gimp_image_add_vectors (image, vectors,
+                          GIMP_IMAGE_ACTIVE_PARENT, -1, TRUE);
+  gimp_image_flush (image);
 
-      gimp_image_add_vectors (options->image, new_vectors,
+  gtk_widget_destroy (dialog);
-                              GIMP_IMAGE_ACTIVE_PARENT, -1, TRUE);
-
-      gimp_image_flush (options->image);
-    }
-
-  gtk_widget_destroy (options->dialog);
 }
 
 static void
-vectors_edit_vectors_response (GtkWidget            *widget,
+vectors_edit_attributes_callback (GtkWidget    *dialog,
-                               gint                  response_id,
+                                  GimpImage    *image,
-                               VectorsOptionsDialog *options)
+                                  GimpVectors  *vectors,
+                                  GimpContext  *context,
+                                  const gchar  *vectors_name,
+                                  gboolean      vectors_visible,
+                                  gboolean      vectors_linked,
+                                  GimpColorTag  vectors_color_tag,
+                                  gboolean      vectors_lock_content,
+                                  gboolean      vectors_lock_position,
+                                  gpointer      user_data)
 {
-  if (response_id == GTK_RESPONSE_OK)
+  GimpItem *item = GIMP_ITEM (vectors);
+
+  if (strcmp (vectors_name, gimp_object_get_name (vectors))      ||
+      vectors_visible       != gimp_item_get_visible (item)      ||
+      vectors_linked        != gimp_item_get_linked (item)       ||
+      vectors_color_tag     != gimp_item_get_color_tag (item)    ||
+      vectors_lock_content  != gimp_item_get_lock_content (item) ||
+      vectors_lock_position != gimp_item_get_lock_position (item))
     {
-      GimpVectors *vectors = options->vectors;
+      gimp_image_undo_group_start (image,
-      const gchar *new_name;
+                                   GIMP_UNDO_GROUP_ITEM_PROPERTIES,
+                                   _("Path Attributes"));
 
-      new_name = gtk_entry_get_text (GTK_ENTRY (options->name_entry));
+      if (strcmp (vectors_name, gimp_object_get_name (vectors)))
+        gimp_item_rename (GIMP_ITEM (vectors), vectors_name, NULL);
 
-      if (strcmp (new_name, gimp_object_get_name (vectors)))
+      if (vectors_visible != gimp_item_get_visible (item))
-        {
+        gimp_item_set_visible (item, vectors_visible, TRUE);
-          gimp_item_rename (GIMP_ITEM (vectors), new_name, NULL);
+
-          gimp_image_flush (options->image);
+      if (vectors_linked != gimp_item_get_linked (item))
-        }
+        gimp_item_set_linked (item, vectors_linked, TRUE);
+
+      if (vectors_color_tag != gimp_item_get_color_tag (item))
+        gimp_item_set_color_tag (item, vectors_color_tag, TRUE);
+
+      if (vectors_lock_content != gimp_item_get_lock_content (item))
+        gimp_item_set_lock_content (item, vectors_lock_content, TRUE);
+
+      if (vectors_lock_position != gimp_item_get_lock_position (item))
+        gimp_item_set_lock_position (item, vectors_lock_position, TRUE);
+
+      gimp_image_undo_group_end (image);
+
+      gimp_image_flush (image);
     }
 
-  gtk_widget_destroy (options->dialog);
+  gtk_widget_destroy (dialog);
 }
 
 static void
-vectors_import_response (GtkWidget           *widget,
+vectors_import_callback (GtkWidget *dialog,
-                         gint                 response_id,
+                         GimpImage *image,
-                         VectorsImportDialog *dialog)
+                         GFile     *file,
+                         GFile     *import_folder,
+                         gboolean   merge_vectors,
+                         gboolean   scale_vectors,
+                         gpointer   user_data)
 {
-  if (response_id == GTK_RESPONSE_OK)
+  GimpDialogConfig *config = GIMP_DIALOG_CONFIG (image->gimp->config);
+  gchar            *path   = NULL;
+  GError           *error  = NULL;
+
+  if (import_folder)
+    path = gimp_file_get_config_path (import_folder, NULL);
+
+  g_object_set (config,
+                "path-import-path",  path,
+                "path-import-merge", merge_vectors,
+                "path-import-scale", scale_vectors,
+                NULL);
+
+  if (path)
+    g_free (path);
+
+  if (gimp_vectors_import_file (image, file,
+                                config->vectors_import_merge,
+                                config->vectors_import_scale,
+                                GIMP_IMAGE_ACTIVE_PARENT, -1,
+                                NULL, &error))
     {
-      GtkFileChooser *chooser = GTK_FILE_CHOOSER (widget);
+      gimp_image_flush (image);
-      GFile          *file;
+    }
-      GError         *error = NULL;
+  else
-
+    {
-      vectors_import_merge = dialog->merge_vectors;
+      gimp_message (image->gimp, G_OBJECT (dialog),
-      vectors_import_scale = dialog->scale_vectors;
+                    GIMP_MESSAGE_ERROR,
-
+                    "%s", error->message);
-      file = gtk_file_chooser_get_file (chooser);
+      g_error_free (error);
-
+      return;
-      if (gimp_vectors_import_file (dialog->image, file,
-                                    vectors_import_merge, vectors_import_scale,
-                                    GIMP_IMAGE_ACTIVE_PARENT, -1,
-                                    NULL, &error))
-        {
-          gimp_image_flush (dialog->image);
-        }
-      else
-        {
-          gimp_message (dialog->image->gimp, G_OBJECT (widget),
-                        GIMP_MESSAGE_ERROR,
-                        "%s", error->message);
-          g_error_free (error);
-          return;
-        }
-
-      g_object_unref (file);
-
-      g_object_set_data_full (G_OBJECT (dialog->image->gimp),
-                              "gimp-vectors-import-folder",
-                              gtk_file_chooser_get_current_folder (chooser),
-                              (GDestroyNotify) g_free);
     }
 
-  gtk_widget_destroy (widget);
+  gtk_widget_destroy (dialog);
 }
 
 static void
-vectors_export_response (GtkWidget           *widget,
+vectors_export_callback (GtkWidget *dialog,
-                         gint                 response_id,
+                         GimpImage *image,
-                         VectorsExportDialog *dialog)
+                         GFile     *file,
+                         GFile     *export_folder,
+                         gboolean   active_only,
+                         gpointer   user_data)
 {
-  if (response_id == GTK_RESPONSE_OK)
+  GimpDialogConfig *config  = GIMP_DIALOG_CONFIG (image->gimp->config);
+  GimpVectors      *vectors = NULL;
+  gchar            *path    = NULL;
+  GError           *error   = NULL;
+
+  if (export_folder)
+    path = gimp_file_get_config_path (export_folder, NULL);
+
+  g_object_set (config,
+                "path-export-path",        path,
+                "path-export-active-only", active_only,
+                NULL);
+
+  if (path)
+    g_free (path);
+
+  if (config->vectors_export_active_only)
+    vectors = gimp_image_get_active_vectors (image);
+
+  if (! gimp_vectors_export_file (image, vectors, file, &error))
     {
-      GtkFileChooser *chooser = GTK_FILE_CHOOSER (widget);
+      gimp_message (image->gimp, G_OBJECT (dialog),
-      GimpVectors    *vectors = NULL;
+                    GIMP_MESSAGE_ERROR,
-      GFile          *file;
+                    "%s", error->message);
-      GError         *error   = NULL;
+      g_clear_error (&error);
-
+      return;
-      vectors_export_active_only = dialog->active_only;
-
-      file = gtk_file_chooser_get_file (chooser);
-
-      if (vectors_export_active_only)
-        vectors = gimp_image_get_active_vectors (dialog->image);
-
-      if (! gimp_vectors_export_file (dialog->image, vectors, file, &error))
-        {
-          gimp_message (dialog->image->gimp, G_OBJECT (widget),
-                        GIMP_MESSAGE_ERROR,
-                        "%s", error->message);
-          g_error_free (error);
-          return;
-        }
-
-      g_object_unref (file);
-
-      g_object_set_data_full (G_OBJECT (dialog->image->gimp),
-                              "gimp-vectors-export-folder",
-                              gtk_file_chooser_get_current_folder (chooser),
-                              (GDestroyNotify) g_free);
     }
 
-  gtk_widget_destroy (widget);
+  gtk_widget_destroy (dialog);
 }

app/actions/vectors-commands.h

@@ -49,6 +49,11 @@ void   vectors_to_selection_cmd_callback         (GtkAction   *action,
 void   vectors_selection_to_vectors_cmd_callback (GtkAction   *action,
                                                   gint         value,
                                                   gpointer     data);
+
+void   vectors_fill_cmd_callback                 (GtkAction   *action,
+                                                  gpointer     data);
+void   vectors_fill_last_vals_cmd_callback       (GtkAction   *action,
+                                                  gpointer     data);
 void   vectors_stroke_cmd_callback               (GtkAction   *action,
                                                   gpointer     data);
 void   vectors_stroke_last_vals_cmd_callback     (GtkAction   *action,
@@ -72,5 +77,9 @@ void   vectors_lock_content_cmd_callback         (GtkAction   *action,
 void   vectors_lock_position_cmd_callback        (GtkAction   *action,
                                                   gpointer     data);
 
+void   vectors_color_tag_cmd_callback            (GtkAction   *action,
+                                                  gint         value,
+                                                  gpointer     data);
+
 
 #endif /* __VECTORS_COMMANDS_H__ */

app/actions/view-actions.c

@@ -22,6 +22,7 @@
 
 #include "libgimpmath/gimpmath.h"
 #include "libgimpcolor/gimpcolor.h"
+#include "libgimpconfig/gimpconfig.h"
 #include "libgimpwidgets/gimpwidgets.h"
 
 #include "actions-types.h"
@@ -68,8 +69,18 @@ static const GimpActionEntry view_actions[] =
 {
   { "view-menu",                NULL, NC_("view-action", "_View")          },
   { "view-zoom-menu",           NULL, NC_("view-action", "_Zoom")          },
-  { "view-rotate-menu",         NULL, NC_("view-action", "_Rotate")        },
+  { "view-rotate-menu",         NULL, NC_("view-action", "_Flip & Rotate") },
   { "view-padding-color-menu",  NULL, NC_("view-action", "_Padding Color") },
+
+  { "view-color-management-menu", NULL,
+    NC_("view-action", "_Color Management") },
+
+  { "view-display-intent-menu", NULL,
+    NC_("view-action", "Display _Rendering Intent") },
+
+  { "view-softproof-intent-menu", NULL,
+    NC_("view-action", "Soft-Proofing Re_ndering Intent") },
+
   { "view-move-to-screen-menu", GIMP_STOCK_MOVE_TO_SCREEN,
     NC_("view-action", "Move to Screen"), NULL, NULL, NULL,
     GIMP_HELP_VIEW_CHANGE_SCREEN },
@@ -98,6 +109,12 @@ static const GimpActionEntry view_actions[] =
     G_CALLBACK (view_zoom_fill_cmd_callback),
     GIMP_HELP_VIEW_ZOOM_FILL },
 
+  { "view-zoom-selection", "gimp-selection",
+    NC_("view-action", "Zoom to _Selection"), NULL,
+    NC_("view-action", "Adjust the zoom ratio so that the selection fills the window"),
+    G_CALLBACK (view_zoom_selection_cmd_callback),
+    GIMP_HELP_VIEW_ZOOM_SELECTION },
+
   { "view-zoom-revert", NULL,
     NC_("view-action", "Re_vert Zoom"), "grave",
     NC_("view-action", "Restore the previous zoom level"),
@@ -122,6 +139,19 @@ static const GimpActionEntry view_actions[] =
     G_CALLBACK (view_display_filters_cmd_callback),
     GIMP_HELP_DISPLAY_FILTER_DIALOG },
 
+  { "view-color-management-reset", GIMP_STOCK_RESET,
+    NC_("view-action", "As in _Preferences"), NULL,
+    NC_("view-action",
+        "Reset color management to what's configured in preferences"),
+    G_CALLBACK (view_color_management_reset_cmd_callback),
+    GIMP_HELP_VIEW_COLOR_MANAGEMENT },
+
+  { "view-softproof-profile", NULL,
+    NC_("view-action", "Soft-_Proofing Profile..."), NULL,
+    NC_("view-action", "Set the soft-proofing profile"),
+    G_CALLBACK (view_softproof_profile_cmd_callback),
+    GIMP_HELP_VIEW_COLOR_MANAGEMENT },
+
   { "view-shrink-wrap", "zoom-fit-best",
     NC_("view-action", "Shrink _Wrap"), "<primary>J",
     NC_("view-action", "Reduce the image window to the size of the image display"),
@@ -144,6 +174,42 @@ static const GimpToggleActionEntry view_toggle_actions[] =
     TRUE,
     GIMP_HELP_VIEW_DOT_FOR_DOT },
 
+  { "view-color-management-enable", NULL,
+    NC_("view-action", "_Color-Manage this View"), NULL,
+    NC_("view-action", "Use color management for this view"),
+    G_CALLBACK (view_color_management_enable_cmd_callback),
+    TRUE,
+    GIMP_HELP_VIEW_COLOR_MANAGEMENT },
+
+  { "view-color-management-softproof", NULL,
+    NC_("view-action", "_Proof Colors"), NULL,
+    NC_("view-action", "Use this view for soft-proofing"),
+    G_CALLBACK (view_color_management_softproof_cmd_callback),
+    FALSE,
+    GIMP_HELP_VIEW_COLOR_MANAGEMENT },
+
+  { "view-display-black-point-compensation", NULL,
+    NC_("view-action", "_Black Point Compensation"), NULL,
+    NC_("view-action", "Use black point compensation for image display"),
+    G_CALLBACK (view_display_bpc_cmd_callback),
+    TRUE,
+    GIMP_HELP_VIEW_COLOR_MANAGEMENT },
+
+  { "view-softproof-black-point-compensation", NULL,
+    NC_("view-action", "_Black Point Compensation"), NULL,
+    NC_("view-action", "Use black point compensation for soft-proofing"),
+    G_CALLBACK (view_softproof_bpc_cmd_callback),
+    TRUE,
+    GIMP_HELP_VIEW_COLOR_MANAGEMENT },
+
+  { "view-softproof-gamut-check", NULL,
+    NC_("view-action", "_Mark Out Of Gamut Colors"), NULL,
+    NC_("view-action", "When soft-proofing, mark colors which cannot "
+        "be represented in the target color space"),
+    G_CALLBACK (view_softproof_gamut_check_cmd_callback),
+    FALSE,
+    GIMP_HELP_VIEW_COLOR_MANAGEMENT },
+
   { "view-show-selection", NULL,
     NC_("view-action", "Show _Selection"), "<primary>T",
     NC_("view-action", "Display the selection outline"),
@@ -388,6 +454,21 @@ static const GimpRadioActionEntry view_zoom_explicit_actions[] =
     GIMP_HELP_VIEW_ZOOM_OTHER }
 };
 
+static const GimpToggleActionEntry view_flip_actions[] =
+{
+  { "view-flip-horizontally", GIMP_STOCK_FLIP_HORIZONTAL,
+    NC_("view-action", "Flip Horizontally"), NULL, NULL,
+    G_CALLBACK (view_flip_horizontally_cmd_callback),
+    FALSE,
+    GIMP_HELP_VIEW_FLIP },
+
+  { "view-flip-vertically", GIMP_STOCK_FLIP_VERTICAL,
+    NC_("view-action", "Flip Vertically"), NULL, NULL,
+    G_CALLBACK (view_flip_vertically_cmd_callback),
+    FALSE,
+    GIMP_HELP_VIEW_FLIP }
+};
+
 static const GimpEnumActionEntry view_rotate_absolute_actions[] =
 {
   { "view-rotate-set-absolute", NULL,
@@ -396,8 +477,9 @@ static const GimpEnumActionEntry view_rotate_absolute_actions[] =
     NULL },
 
   { "view-rotate-reset", GIMP_STOCK_RESET,
-    NC_("view-action", "_Reset to 0°"), "exclam",
+    NC_("view-action", "_Reset Flip & Rotate"), "exclam",
-    NC_("view-action", "Reset the angle of rotation to 0°"),
+    NC_("view-action",
+        "Reset flipping to unflipped and the angle of rotation to 0°"),
     GIMP_ACTION_SELECT_SET_TO_DEFAULT, FALSE,
     GIMP_HELP_VIEW_ROTATE_RESET },
 };
@@ -435,6 +517,60 @@ static const GimpEnumActionEntry view_rotate_relative_actions[] =
     GIMP_HELP_VIEW_ROTATE_345 }
 };
 
+static const GimpRadioActionEntry view_display_intent_actions[] =
+{
+  { "view-display-intent-perceptual", NULL,
+    NC_("view-action", "_Perceptual"), NULL,
+    NC_("view-action", "Display rendering intent is perceptual"),
+    GIMP_COLOR_RENDERING_INTENT_PERCEPTUAL,
+    GIMP_HELP_VIEW_COLOR_MANAGEMENT },
+
+  { "view-display-intent-relative-colorimetric", NULL,
+    NC_("view-action", "_Relative Colorimetric"), NULL,
+    NC_("view-action", "Display rendering intent is relative colorimetric"),
+    GIMP_COLOR_RENDERING_INTENT_RELATIVE_COLORIMETRIC,
+    GIMP_HELP_VIEW_COLOR_MANAGEMENT },
+
+  { "view-display-intent-saturation", NULL,
+    NC_("view-action", "_Saturation"), NULL,
+    NC_("view-action", "Display rendering intent is saturation"),
+    GIMP_COLOR_RENDERING_INTENT_SATURATION,
+    GIMP_HELP_VIEW_COLOR_MANAGEMENT },
+
+  { "view-display-intent-absolute-colorimetric", NULL,
+    NC_("view-action", "_Absolute Colorimetric"), NULL,
+    NC_("view-action", "Display rendering intent is absolute colorimetric"),
+    GIMP_COLOR_RENDERING_INTENT_ABSOLUTE_COLORIMETRIC,
+    GIMP_HELP_VIEW_COLOR_MANAGEMENT }
+};
+
+static const GimpRadioActionEntry view_softproof_intent_actions[] =
+{
+  { "view-softproof-intent-perceptual", NULL,
+    NC_("view-action", "_Perceptual"), NULL,
+    NC_("view-action", "Soft-proofing rendering intent is perceptual"),
+    GIMP_COLOR_RENDERING_INTENT_PERCEPTUAL,
+    GIMP_HELP_VIEW_COLOR_MANAGEMENT },
+
+  { "view-softproof-intent-relative-colorimetric", NULL,
+    NC_("view-action", "_Relative Colorimetric"), NULL,
+    NC_("view-action", "Soft-proofing rendering intent is relative colorimetric"),
+    GIMP_COLOR_RENDERING_INTENT_RELATIVE_COLORIMETRIC,
+    GIMP_HELP_VIEW_COLOR_MANAGEMENT },
+
+  { "view-softproof-intent-saturation", NULL,
+    NC_("view-action", "_Saturation"), NULL,
+    NC_("view-action", "Soft-proofing rendering intent is saturation"),
+    GIMP_COLOR_RENDERING_INTENT_SATURATION,
+    GIMP_HELP_VIEW_COLOR_MANAGEMENT },
+
+  { "view-softproof-intent-absolute-colorimetric", NULL,
+    NC_("view-action", "_Absolute Colorimetric"), NULL,
+    NC_("view-action", "Soft-proofing rendering intent is absolute colorimetric"),
+    GIMP_COLOR_RENDERING_INTENT_ABSOLUTE_COLORIMETRIC,
+    GIMP_HELP_VIEW_COLOR_MANAGEMENT }
+};
+
 static const GimpEnumActionEntry view_padding_color_actions[] =
 {
   { "view-padding-color-theme", NULL,
@@ -456,7 +592,7 @@ static const GimpEnumActionEntry view_padding_color_actions[] =
     GIMP_HELP_VIEW_PADDING_COLOR },
 
   { "view-padding-color-custom", "gtk-select-color",
-    NC_("view-padding-color", "Select _Custom Color..."), NULL,
+    NC_("view-padding-color", "_Custom Color..."), NULL,
     NC_("view-padding-color", "Use an arbitrary color"),
     GIMP_CANVAS_PADDING_MODE_CUSTOM, FALSE,
     GIMP_HELP_VIEW_PADDING_COLOR },
@@ -571,6 +707,10 @@ view_actions_setup (GimpActionGroup *group)
                                        10000,
                                        G_CALLBACK (view_zoom_explicit_cmd_callback));
 
+  gimp_action_group_add_toggle_actions (group, "view-action",
+                                        view_flip_actions,
+                                        G_N_ELEMENTS (view_flip_actions));
+
   gimp_action_group_add_enum_actions (group, "view-action",
                                       view_rotate_absolute_actions,
                                       G_N_ELEMENTS (view_rotate_absolute_actions),
@@ -581,6 +721,20 @@ view_actions_setup (GimpActionGroup *group)
                                       G_N_ELEMENTS (view_rotate_relative_actions),
                                       G_CALLBACK (view_rotate_relative_cmd_callback));
 
+  gimp_action_group_add_radio_actions (group, "view-action",
+                                       view_display_intent_actions,
+                                       G_N_ELEMENTS (view_display_intent_actions),
+                                       NULL,
+                                       GIMP_COLOR_MANAGEMENT_DISPLAY,
+                                       G_CALLBACK (view_display_intent_cmd_callback));
+
+  gimp_action_group_add_radio_actions (group, "view-action",
+                                       view_softproof_intent_actions,
+                                       G_N_ELEMENTS (view_softproof_intent_actions),
+                                       NULL,
+                                       GIMP_COLOR_MANAGEMENT_DISPLAY,
+                                       G_CALLBACK (view_softproof_intent_cmd_callback));
+
   gimp_action_group_add_enum_actions (group, "view-padding-color",
                                       view_padding_color_actions,
                                       G_N_ELEMENTS (view_padding_color_actions),
@@ -627,17 +781,26 @@ void
 view_actions_update (GimpActionGroup *group,
                      gpointer         data)
 {
-  GimpDisplay        *display        = action_data_get_display (data);
+  GimpDisplay        *display           = action_data_get_display (data);
-  GimpImage          *image          = NULL;
+  GimpImage          *image             = NULL;
-  GimpDisplayShell   *shell          = NULL;
+  GimpDisplayShell   *shell             = NULL;
-  GimpDisplayOptions *options        = NULL;
+  GimpDisplayOptions *options           = NULL;
-  gchar              *label          = NULL;
+  GimpColorConfig    *color_config      = NULL;
-  gboolean            fullscreen     = FALSE;
+  gchar              *label             = NULL;
-  gboolean            revert_enabled = FALSE;   /* able to revert zoom? */
+  gboolean            fullscreen        = FALSE;
+  gboolean            revert_enabled    = FALSE;   /* able to revert zoom? */
+  gboolean            flip_horizontally = FALSE;
+  gboolean            flip_vertically   = FALSE;
+  gboolean            cm                = FALSE;
+  gboolean            sp                = FALSE;
+  gboolean            d_bpc             = FALSE;
+  gboolean            s_bpc             = FALSE;
+  gboolean            gammut            = FALSE;
 
   if (display)
     {
       GimpImageWindow *window;
+      const gchar     *action = NULL;
 
       image  = gimp_display_get_image (display);
       shell  = gimp_display_get_shell (display);
@@ -651,6 +814,72 @@ view_actions_update (GimpActionGroup *group,
                  shell->no_image_options);
 
       revert_enabled = gimp_display_shell_scale_can_revert (shell);
+
+      flip_horizontally = shell->flip_horizontally;
+      flip_vertically   = shell->flip_vertically;
+
+      color_config = gimp_display_shell_get_color_config (shell);
+
+      switch (gimp_color_config_get_mode (color_config))
+        {
+        case GIMP_COLOR_MANAGEMENT_OFF:
+          break;
+
+        case GIMP_COLOR_MANAGEMENT_DISPLAY:
+          cm = (image != NULL);
+          break;
+
+        case GIMP_COLOR_MANAGEMENT_SOFTPROOF:
+          cm = (image != NULL);
+          sp = (image != NULL);
+          break;
+        }
+
+      switch (gimp_color_config_get_display_intent (color_config))
+        {
+        case GIMP_COLOR_RENDERING_INTENT_PERCEPTUAL:
+          action = "view-display-intent-perceptual";
+          break;
+
+        case GIMP_COLOR_RENDERING_INTENT_RELATIVE_COLORIMETRIC:
+          action = "view-display-intent-relative-colorimetric";
+          break;
+
+        case GIMP_COLOR_RENDERING_INTENT_SATURATION:
+          action = "view-display-intent-saturation";
+          break;
+
+        case GIMP_COLOR_RENDERING_INTENT_ABSOLUTE_COLORIMETRIC:
+          action = "view-display-intent-absolute-colorimetric";
+          break;
+        }
+
+      gimp_action_group_set_action_active (group, action, TRUE);
+
+      switch (gimp_color_config_get_simulation_intent (color_config))
+        {
+        case GIMP_COLOR_RENDERING_INTENT_PERCEPTUAL:
+          action = "view-softproof-intent-perceptual";
+          break;
+
+        case GIMP_COLOR_RENDERING_INTENT_RELATIVE_COLORIMETRIC:
+          action = "view-softproof-intent-relative-colorimetric";
+          break;
+
+        case GIMP_COLOR_RENDERING_INTENT_SATURATION:
+          action = "view-softproof-intent-saturation";
+          break;
+
+        case GIMP_COLOR_RENDERING_INTENT_ABSOLUTE_COLORIMETRIC:
+          action = "view-softproof-intent-absolute-colorimetric";
+          break;
+        }
+
+      gimp_action_group_set_action_active (group, action, TRUE);
+
+      d_bpc  = gimp_color_config_get_display_bpc (color_config);
+      s_bpc  = gimp_color_config_get_simulation_bpc (color_config);
+      gammut = gimp_color_config_get_simulation_gamut_check (color_config);
     }
 
 #define SET_ACTIVE(action,condition) \
@@ -680,43 +909,50 @@ view_actions_update (GimpActionGroup *group,
                                           _("Re_vert Zoom"));
     }
 
-  SET_SENSITIVE ("view-zoom",            image);
+  SET_SENSITIVE ("view-zoom",              image);
-  SET_SENSITIVE ("view-zoom-minimum",    image);
+  SET_SENSITIVE ("view-zoom-minimum",      image);
-  SET_SENSITIVE ("view-zoom-maximum",    image);
+  SET_SENSITIVE ("view-zoom-maximum",      image);
-  SET_SENSITIVE ("view-zoom-in",         image);
+  SET_SENSITIVE ("view-zoom-in",           image);
-  SET_SENSITIVE ("view-zoom-in-accel",   image);
+  SET_SENSITIVE ("view-zoom-in-accel",     image);
-  SET_SENSITIVE ("view-zoom-in-skip",    image);
+  SET_SENSITIVE ("view-zoom-in-skip",      image);
-  SET_SENSITIVE ("view-zoom-out",        image);
+  SET_SENSITIVE ("view-zoom-out",          image);
-  SET_SENSITIVE ("view-zoom-out-accel",  image);
+  SET_SENSITIVE ("view-zoom-out-accel",    image);
-  SET_SENSITIVE ("view-zoom-out-skip",   image);
+  SET_SENSITIVE ("view-zoom-out-skip",     image);
 
-  SET_SENSITIVE ("view-zoom-fit-in",     image);
+  SET_SENSITIVE ("view-zoom-fit-in",       image);
-  SET_SENSITIVE ("view-zoom-fill",       image);
+  SET_SENSITIVE ("view-zoom-fill",         image);
-  SET_SENSITIVE ("view-zoom-revert",     image);
+  SET_SENSITIVE ("view-zoom-selection",    image);
+  SET_SENSITIVE ("view-zoom-revert",       image);
 
-  SET_SENSITIVE ("view-zoom-16-1",       image);
+  SET_SENSITIVE ("view-zoom-16-1",         image);
-  SET_SENSITIVE ("view-zoom-16-1-accel", image);
+  SET_SENSITIVE ("view-zoom-16-1-accel",   image);
-  SET_SENSITIVE ("view-zoom-8-1",        image);
+  SET_SENSITIVE ("view-zoom-8-1",          image);
-  SET_SENSITIVE ("view-zoom-8-1-accel",  image);
+  SET_SENSITIVE ("view-zoom-8-1-accel",    image);
-  SET_SENSITIVE ("view-zoom-4-1",        image);
+  SET_SENSITIVE ("view-zoom-4-1",          image);
-  SET_SENSITIVE ("view-zoom-4-1-accel",  image);
+  SET_SENSITIVE ("view-zoom-4-1-accel",    image);
-  SET_SENSITIVE ("view-zoom-2-1",        image);
+  SET_SENSITIVE ("view-zoom-2-1",          image);
-  SET_SENSITIVE ("view-zoom-2-1-accel",  image);
+  SET_SENSITIVE ("view-zoom-2-1-accel",    image);
-  SET_SENSITIVE ("view-zoom-1-1",        image);
+  SET_SENSITIVE ("view-zoom-1-1",          image);
-  SET_SENSITIVE ("view-zoom-1-1-accel",  image);
+  SET_SENSITIVE ("view-zoom-1-1-accel",    image);
-  SET_SENSITIVE ("view-zoom-1-2",        image);
+  SET_SENSITIVE ("view-zoom-1-2",          image);
-  SET_SENSITIVE ("view-zoom-1-4",        image);
+  SET_SENSITIVE ("view-zoom-1-4",          image);
-  SET_SENSITIVE ("view-zoom-1-8",        image);
+  SET_SENSITIVE ("view-zoom-1-8",          image);
-  SET_SENSITIVE ("view-zoom-1-16",       image);
+  SET_SENSITIVE ("view-zoom-1-16",         image);
-  SET_SENSITIVE ("view-zoom-other",      image);
+  SET_SENSITIVE ("view-zoom-other",        image);
 
-  SET_SENSITIVE ("view-rotate-reset",    image);
+  SET_SENSITIVE ("view-flip-horizontally", image);
-  SET_SENSITIVE ("view-rotate-15",       image);
+  SET_ACTIVE    ("view-flip-horizontally", flip_horizontally);
-  SET_SENSITIVE ("view-rotate-345",      image);
+
-  SET_SENSITIVE ("view-rotate-90",       image);
+  SET_SENSITIVE ("view-flip-vertically",   image);
-  SET_SENSITIVE ("view-rotate-180",      image);
+  SET_ACTIVE    ("view-flip-vertically",   flip_vertically);
-  SET_SENSITIVE ("view-rotate-270",      image);
+
-  SET_SENSITIVE ("view-rotate-other",    image);
+  SET_SENSITIVE ("view-rotate-reset",      image);
+  SET_SENSITIVE ("view-rotate-15",         image);
+  SET_SENSITIVE ("view-rotate-345",        image);
+  SET_SENSITIVE ("view-rotate-90",         image);
+  SET_SENSITIVE ("view-rotate-180",        image);
+  SET_SENSITIVE ("view-rotate-270",        image);
+  SET_SENSITIVE ("view-rotate-other",      image);
 
   if (image)
     {
@@ -727,6 +963,27 @@ view_actions_update (GimpActionGroup *group,
   SET_SENSITIVE ("view-navigation-window", image);
   SET_SENSITIVE ("view-display-filters",   image);
 
+  SET_SENSITIVE ("view-color-management-enable",                image);
+  SET_ACTIVE    ("view-color-management-enable",                cm);
+  SET_SENSITIVE ("view-color-management-softproof",             image);
+  SET_ACTIVE    ("view-color-management-softproof",             sp);
+  SET_SENSITIVE ("view-display-intent-perceptual",              cm);
+  SET_SENSITIVE ("view-display-intent-relative-colorimetric",   cm);
+  SET_SENSITIVE ("view-display-intent-saturation",              cm);
+  SET_SENSITIVE ("view-display-intent-absolute-colorimetric",   cm);
+  SET_SENSITIVE ("view-display-black-point-compensation",       cm);
+  SET_ACTIVE    ("view-display-black-point-compensation",       d_bpc);
+  SET_SENSITIVE ("view-softproof-profile",                      sp);
+  SET_SENSITIVE ("view-softproof-intent-perceptual",            sp);
+  SET_SENSITIVE ("view-softproof-intent-relative-colorimetric", sp);
+  SET_SENSITIVE ("view-softproof-intent-saturation",            sp);
+  SET_SENSITIVE ("view-softproof-intent-absolute-colorimetric", sp);
+  SET_SENSITIVE ("view-softproof-black-point-compensation",     sp);
+  SET_ACTIVE    ("view-softproof-black-point-compensation",     s_bpc);
+  SET_SENSITIVE ("view-softproof-gamut-check",                  sp);
+  SET_ACTIVE    ("view-softproof-gamut-check",                  gammut);
+  SET_SENSITIVE ("view-color-management-reset",                 image);
+
   SET_SENSITIVE ("view-show-selection",      image);
   SET_ACTIVE    ("view-show-selection",      display && options->show_selection);
   SET_SENSITIVE ("view-show-layer-boundary", image);
@@ -859,9 +1116,32 @@ static void
 view_actions_set_rotate (GimpActionGroup  *group,
                          GimpDisplayShell *shell)
 {
-  gchar *label;
+  const gchar *flip;
+  gchar       *label;
 
-  label = g_strdup_printf (_("_Rotate (%d°)"), (gint) shell->rotate_angle);
+  if (shell->flip_horizontally &&
+      shell->flip_vertically)
+    {
+      /* please preserve the trailing space */
+      flip = _("(H+V) ");
+    }
+  else if (shell->flip_horizontally)
+    {
+      /* please preserve the trailing space */
+      flip = _("(H) ");
+    }
+  else if (shell->flip_vertically)
+    {
+      /* please preserve the trailing space */
+      flip = _("(V) ");
+    }
+  else
+    {
+      flip = "";
+    }
+
+  label = g_strdup_printf (_("_Flip %s& Rotate (%d°)"),
+                           flip, (gint) shell->rotate_angle);
   gimp_action_group_set_action_label (group, "view-rotate-menu", label);
   g_free (label);
 }

app/actions/view-commands.c

@@ -21,6 +21,7 @@
 #include <gtk/gtk.h>
 
 #include "libgimpmath/gimpmath.h"
+#include "libgimpconfig/gimpconfig.h"
 #include "libgimpwidgets/gimpwidgets.h"
 
 #include "actions-types.h"
@@ -54,6 +55,9 @@
 #include "display/gimpdisplayshell-close.h"
 #include "display/gimpimagewindow.h"
 
+#include "dialogs/color-profile-dialog.h"
+#include "dialogs/dialogs.h"
+
 #include "actions.h"
 #include "view-commands.h"
 
@@ -72,10 +76,17 @@
 
 /*  local function prototypes  */
 
-static void   view_padding_color_dialog_update (GimpColorDialog      *dialog,
+static void   view_softproof_profile_callback  (GtkWidget                *dialog,
-                                                const GimpRGB        *color,
+                                                GimpImage                *image,
-                                                GimpColorDialogState  state,
+                                                GimpColorProfile         *new_profile,
-                                                GimpDisplayShell     *shell);
+                                                GFile                    *new_file,
+                                                GimpColorRenderingIntent  intent,
+                                                gboolean                  bpc,
+                                                gpointer                  user_data);
+static void   view_padding_color_dialog_update (GimpColorDialog          *dialog,
+                                                const GimpRGB            *color,
+                                                GimpColorDialogState      state,
+                                                GimpDisplayShell         *shell);
 
 
 /*  public functions  */
@@ -134,6 +145,25 @@ view_zoom_fill_cmd_callback (GtkAction *action,
   gimp_display_shell_scale_fill (gimp_display_get_shell (display));
 }
 
+void
+view_zoom_selection_cmd_callback (GtkAction *action,
+                                  gpointer   data)
+{
+  GimpDisplay *display;
+  GimpImage   *image;
+  gint         x, y, width, height;
+  return_if_no_display (display, data);
+  return_if_no_image (image, data);
+
+  gimp_item_bounds (GIMP_ITEM (gimp_image_get_mask (image)),
+                    &x, &y, &width, &height);
+
+  gimp_display_shell_scale_to_rectangle (gimp_display_get_shell (display),
+                                         GIMP_ZOOM_IN,
+                                         x, y, width, height,
+                                         FALSE);
+}
+
 void
 view_zoom_revert_cmd_callback (GtkAction *action,
                                gpointer   data)
@@ -286,6 +316,44 @@ view_dot_for_dot_cmd_callback (GtkAction *action,
     }
 }
 
+void
+view_flip_horizontally_cmd_callback (GtkAction *action,
+                                     gpointer   data)
+{
+  GimpDisplay      *display;
+  GimpDisplayShell *shell;
+  gboolean          active;
+  return_if_no_display (display, data);
+
+  shell = gimp_display_get_shell (display);
+
+  active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+
+  if (active != shell->flip_horizontally)
+    {
+      gimp_display_shell_flip (shell, active, shell->flip_vertically);
+    }
+}
+
+void
+view_flip_vertically_cmd_callback (GtkAction *action,
+                                   gpointer   data)
+{
+  GimpDisplay      *display;
+  GimpDisplayShell *shell;
+  gboolean          active;
+  return_if_no_display (display, data);
+
+  shell = gimp_display_get_shell (display);
+
+  active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+
+  if (active != shell->flip_vertically)
+    {
+      gimp_display_shell_flip (shell, shell->flip_horizontally, active);
+    }
+}
+
 void
 view_rotate_absolute_cmd_callback (GtkAction *action,
                                    gint       value,
@@ -305,6 +373,9 @@ view_rotate_absolute_cmd_callback (GtkAction *action,
                                TRUE);
 
   gimp_display_shell_rotate_to (shell, angle);
+
+  if (value == GIMP_ACTION_SELECT_SET_TO_DEFAULT)
+    gimp_display_shell_flip (shell, FALSE, FALSE);
 }
 
 void
@@ -411,18 +482,262 @@ view_display_filters_cmd_callback (GtkAction *action,
                                    gpointer   data)
 {
   GimpDisplayShell *shell;
+  GtkWidget        *dialog;
   return_if_no_shell (shell, data);
 
-  if (! shell->filters_dialog)
+#define FILTERS_DIALOG_KEY "gimp-display-filters-dialog"
-    {
-      shell->filters_dialog = gimp_display_shell_filter_dialog_new (shell);
 
-      g_signal_connect (shell->filters_dialog, "destroy",
+  dialog = dialogs_get_dialog (G_OBJECT (shell), FILTERS_DIALOG_KEY);
-                        G_CALLBACK (gtk_widget_destroyed),
+
-                        &shell->filters_dialog);
+  if (! dialog)
+    {
+      dialog = gimp_display_shell_filter_dialog_new (shell);
+
+      dialogs_attach_dialog (G_OBJECT (shell), FILTERS_DIALOG_KEY, dialog);
     }
 
-  gtk_window_present (GTK_WINDOW (shell->filters_dialog));
+  gtk_window_present (GTK_WINDOW (dialog));
+}
+
+void
+view_color_management_reset_cmd_callback (GtkAction *action,
+                                          gpointer   data)
+{
+  GimpDisplayShell *shell;
+  GimpColorConfig  *global_config;
+  GimpColorConfig  *shell_config;
+  return_if_no_shell (shell, data);
+
+  global_config = GIMP_CORE_CONFIG (shell->display->config)->color_management;
+  shell_config  = gimp_display_shell_get_color_config (shell);
+
+  gimp_config_copy (GIMP_CONFIG (global_config),
+                    GIMP_CONFIG (shell_config),
+                    0);
+  shell->color_config_set = FALSE;
+}
+
+void
+view_color_management_enable_cmd_callback (GtkAction *action,
+                                           gpointer   data)
+{
+  GimpDisplayShell        *shell;
+  GimpColorConfig         *color_config;
+  GimpColorManagementMode  mode;
+  gboolean                 active;
+  return_if_no_shell (shell, data);
+
+  color_config = gimp_display_shell_get_color_config (shell);
+
+  active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+
+  mode = gimp_color_config_get_mode (color_config);
+
+  if (active)
+    {
+      if (mode != GIMP_COLOR_MANAGEMENT_SOFTPROOF)
+        mode = GIMP_COLOR_MANAGEMENT_DISPLAY;
+    }
+  else
+    {
+      mode = GIMP_COLOR_MANAGEMENT_OFF;
+    }
+
+  if (mode != gimp_color_config_get_mode (color_config))
+    {
+      g_object_set (color_config,
+                    "mode", mode,
+                    NULL);
+      shell->color_config_set = TRUE;
+    }
+}
+
+void
+view_color_management_softproof_cmd_callback (GtkAction *action,
+                                              gpointer   data)
+{
+  GimpDisplayShell        *shell;
+  GimpColorConfig         *color_config;
+  GimpColorManagementMode  mode;
+  gboolean                 active;
+  return_if_no_shell (shell, data);
+
+  color_config = gimp_display_shell_get_color_config (shell);
+
+  active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+
+  mode = gimp_color_config_get_mode (color_config);
+
+  if (active)
+    {
+      mode = GIMP_COLOR_MANAGEMENT_SOFTPROOF;
+    }
+  else
+    {
+      if (mode != GIMP_COLOR_MANAGEMENT_OFF)
+        mode = GIMP_COLOR_MANAGEMENT_DISPLAY;
+    }
+
+  if (mode != gimp_color_config_get_mode (color_config))
+    {
+      g_object_set (color_config,
+                    "mode", mode,
+                    NULL);
+      shell->color_config_set = TRUE;
+    }
+}
+
+void
+view_display_intent_cmd_callback (GtkAction *action,
+                                  GtkAction *current,
+                                  gpointer   data)
+{
+  GimpDisplayShell          *shell;
+  GimpColorConfig           *color_config;
+  GimpColorRenderingIntent   value;
+  return_if_no_shell (shell, data);
+
+  color_config = gimp_display_shell_get_color_config (shell);
+
+  value = gtk_radio_action_get_current_value (GTK_RADIO_ACTION (action));
+
+  if (value != gimp_color_config_get_display_intent (color_config))
+    {
+      g_object_set (color_config,
+                    "display-rendering-intent", value,
+                    NULL);
+      shell->color_config_set = TRUE;
+    }
+}
+
+void
+view_display_bpc_cmd_callback (GtkAction *action,
+                               gpointer   data)
+{
+  GimpDisplayShell *shell;
+  GimpColorConfig  *color_config;
+  gboolean          active;
+  return_if_no_shell (shell, data);
+
+  color_config = gimp_display_shell_get_color_config (shell);
+
+  active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+
+  if (active != gimp_color_config_get_display_bpc (color_config))
+    {
+      g_object_set (color_config,
+                    "display-use-black-point-compensation", active,
+                    NULL);
+      shell->color_config_set = TRUE;
+    }
+}
+
+void
+view_softproof_profile_cmd_callback (GtkAction *action,
+                                     gpointer   data)
+{
+  GimpImage        *image;
+  GimpDisplayShell *shell;
+  GimpColorConfig  *color_config;
+  GtkWidget        *dialog;
+  return_if_no_image (image, data);
+  return_if_no_shell (shell, data);
+
+  color_config = gimp_display_shell_get_color_config (shell);
+
+#define SOFTPROOF_PROFILE_DIALOG_KEY "gimp-softproof-profile-dialog"
+
+  dialog = dialogs_get_dialog (G_OBJECT (shell), SOFTPROOF_PROFILE_DIALOG_KEY);
+
+  if (! dialog)
+    {
+      GimpColorProfile *current_profile;
+
+      current_profile = gimp_color_config_get_simulation_color_profile (color_config,
+                                                                        NULL);
+
+      dialog = color_profile_dialog_new (COLOR_PROFILE_DIALOG_SELECT_SOFTPROOF_PROFILE,
+                                         image,
+                                         action_data_get_context (data),
+                                         GTK_WIDGET (shell),
+                                         current_profile,
+                                         NULL,
+                                         0, 0,
+                                         view_softproof_profile_callback,
+                                         shell);
+
+      dialogs_attach_dialog (G_OBJECT (shell),
+                             SOFTPROOF_PROFILE_DIALOG_KEY, dialog);
+    }
+
+  gtk_window_present (GTK_WINDOW (dialog));
+}
+
+void
+view_softproof_intent_cmd_callback (GtkAction *action,
+                                    GtkAction *current,
+                                    gpointer   data)
+{
+  GimpDisplayShell          *shell;
+  GimpColorConfig           *color_config;
+  GimpColorRenderingIntent   value;
+  return_if_no_shell (shell, data);
+
+  color_config = gimp_display_shell_get_color_config (shell);
+
+  value = gtk_radio_action_get_current_value (GTK_RADIO_ACTION (action));
+
+  if (value != gimp_color_config_get_simulation_intent (color_config))
+    {
+      g_object_set (color_config,
+                    "simulation-rendering-intent", value,
+                    NULL);
+      shell->color_config_set = TRUE;
+    }
+}
+
+void
+view_softproof_bpc_cmd_callback (GtkAction *action,
+                                 gpointer   data)
+{
+  GimpDisplayShell *shell;
+  GimpColorConfig  *color_config;
+  gboolean          active;
+  return_if_no_shell (shell, data);
+
+  color_config = gimp_display_shell_get_color_config (shell);
+
+  active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+
+  if (active != gimp_color_config_get_simulation_bpc (color_config))
+    {
+      g_object_set (color_config,
+                    "simulation-use-black-point-compensation", active,
+                    NULL);
+      shell->color_config_set = TRUE;
+    }
+}
+
+void
+view_softproof_gamut_check_cmd_callback (GtkAction *action,
+                                         gpointer   data)
+{
+  GimpDisplayShell *shell;
+  GimpColorConfig  *color_config;
+  gboolean          active;
+  return_if_no_shell (shell, data);
+
+  color_config = gimp_display_shell_get_color_config (shell);
+
+  active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+
+  if (active != gimp_color_config_get_simulation_gamut_check (color_config))
+    {
+      g_object_set (color_config,
+                    "simulation-gamut-check", active,
+                    NULL);
+      shell->color_config_set = TRUE;
+    }
 }
 
 void
@@ -430,13 +745,15 @@ view_toggle_selection_cmd_callback (GtkAction *action,
                                     gpointer   data)
 {
   GimpDisplayShell *shell;
-  gboolean          active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+  gboolean          active;
   return_if_no_shell (shell, data);
 
-  if (active == gimp_display_shell_get_show_selection (shell))
+  active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
-    return;
 
-  gimp_display_shell_set_show_selection (shell, active);
+  if (active != gimp_display_shell_get_show_selection (shell))
+    {
+      gimp_display_shell_set_show_selection (shell, active);
+    }
 }
 
 void
@@ -444,13 +761,15 @@ view_toggle_layer_boundary_cmd_callback (GtkAction *action,
                                          gpointer   data)
 {
   GimpDisplayShell *shell;
-  gboolean          active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+  gboolean          active;
   return_if_no_shell (shell, data);
 
-  if (active == gimp_display_shell_get_show_layer (shell))
+  active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
-    return;
 
-  gimp_display_shell_set_show_layer (shell, active);
+  if (active != gimp_display_shell_get_show_layer (shell))
+    {
+      gimp_display_shell_set_show_layer (shell, active);
+    }
 }
 
 void
@@ -458,13 +777,15 @@ view_toggle_menubar_cmd_callback (GtkAction *action,
                                   gpointer   data)
 {
   GimpDisplayShell *shell;
-  gboolean          active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+  gboolean          active;
   return_if_no_shell (shell, data);
 
-  if (active == gimp_display_shell_get_show_menubar (shell))
+  active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
-    return;
 
-  gimp_display_shell_set_show_menubar (shell, active);
+  if (active != gimp_display_shell_get_show_menubar (shell))
+    {
+      gimp_display_shell_set_show_menubar (shell, active);
+    }
 }
 
 void
@@ -472,13 +793,15 @@ view_toggle_rulers_cmd_callback (GtkAction *action,
                                  gpointer   data)
 {
   GimpDisplayShell *shell;
-  gboolean          active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+  gboolean          active;
   return_if_no_shell (shell, data);
 
-  if (active == gimp_display_shell_get_show_rulers (shell))
+  active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
-    return;
 
-  gimp_display_shell_set_show_rulers (shell, active);
+  if (active != gimp_display_shell_get_show_rulers (shell))
+    {
+      gimp_display_shell_set_show_rulers (shell, active);
+    }
 }
 
 void
@@ -486,13 +809,15 @@ view_toggle_scrollbars_cmd_callback (GtkAction *action,
                                      gpointer   data)
 {
   GimpDisplayShell *shell;
-  gboolean          active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+  gboolean          active;
   return_if_no_shell (shell, data);
 
-  if (active == gimp_display_shell_get_show_scrollbars (shell))
+  active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
-    return;
 
-  gimp_display_shell_set_show_scrollbars (shell, active);
+  if (active != gimp_display_shell_get_show_scrollbars (shell))
+    {
+      gimp_display_shell_set_show_scrollbars (shell, active);
+    }
 }
 
 void
@@ -500,13 +825,15 @@ view_toggle_statusbar_cmd_callback (GtkAction *action,
                                     gpointer   data)
 {
   GimpDisplayShell *shell;
-  gboolean          active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+  gboolean          active;
   return_if_no_shell (shell, data);
 
-  if (active == gimp_display_shell_get_show_statusbar (shell))
+  active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
-    return;
 
-  gimp_display_shell_set_show_statusbar (shell, active);
+  if (active != gimp_display_shell_get_show_statusbar (shell))
+    {
+      gimp_display_shell_set_show_statusbar (shell, active);
+    }
 }
 
 void
@@ -514,13 +841,15 @@ view_toggle_guides_cmd_callback (GtkAction *action,
                                  gpointer   data)
 {
   GimpDisplayShell *shell;
-  gboolean          active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+  gboolean          active;
   return_if_no_shell (shell, data);
 
-  if (active == gimp_display_shell_get_show_guides (shell))
+  active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
-    return;
 
-  gimp_display_shell_set_show_guides (shell, active);
+  if (active != gimp_display_shell_get_show_guides (shell))
+    {
+      gimp_display_shell_set_show_guides (shell, active);
+    }
 }
 
 void
@@ -528,13 +857,15 @@ view_toggle_grid_cmd_callback (GtkAction *action,
                                gpointer   data)
 {
   GimpDisplayShell *shell;
-  gboolean          active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+  gboolean          active;
   return_if_no_shell (shell, data);
 
-  if (active == gimp_display_shell_get_show_grid (shell))
+  active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
-    return;
 
-  gimp_display_shell_set_show_grid (shell, active);
+  if (active != gimp_display_shell_get_show_grid (shell))
+    {
+      gimp_display_shell_set_show_grid (shell, active);
+    }
 }
 
 void
@@ -542,13 +873,15 @@ view_toggle_sample_points_cmd_callback (GtkAction *action,
                                         gpointer   data)
 {
   GimpDisplayShell *shell;
-  gboolean          active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+  gboolean          active;
   return_if_no_shell (shell, data);
 
-  if (active == gimp_display_shell_get_show_sample_points (shell))
+  active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
-    return;
 
-  gimp_display_shell_set_show_sample_points (shell, active);
+  if (active != gimp_display_shell_get_show_sample_points (shell))
+    {
+      gimp_display_shell_set_show_sample_points (shell, active);
+    }
 }
 
 void
@@ -556,13 +889,15 @@ view_snap_to_guides_cmd_callback (GtkAction *action,
                                   gpointer   data)
 {
   GimpDisplayShell *shell;
-  gboolean          active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+  gboolean          active;
   return_if_no_shell (shell, data);
 
-  if (active == gimp_display_shell_get_snap_to_guides (shell))
+  active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
-    return;
 
-  gimp_display_shell_set_snap_to_guides (shell, active);
+  if (active != gimp_display_shell_get_snap_to_guides (shell))
+    {
+      gimp_display_shell_set_snap_to_guides (shell, active);
+    }
 }
 
 void
@@ -570,13 +905,15 @@ view_snap_to_grid_cmd_callback (GtkAction *action,
                                 gpointer   data)
 {
   GimpDisplayShell *shell;
-  gboolean          active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+  gboolean          active;
   return_if_no_shell (shell, data);
 
-  if (active == gimp_display_shell_get_snap_to_grid (shell))
+  active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
-    return;
 
-  gimp_display_shell_set_snap_to_grid (shell, active);
+  if (active != gimp_display_shell_get_snap_to_grid (shell))
+    {
+      gimp_display_shell_set_snap_to_grid (shell, active);
+    }
 }
 
 void
@@ -584,13 +921,15 @@ view_snap_to_canvas_cmd_callback (GtkAction *action,
                                   gpointer   data)
 {
   GimpDisplayShell *shell;
-  gboolean          active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+  gboolean          active;
   return_if_no_shell (shell, data);
 
-  if (active == gimp_display_shell_get_snap_to_canvas (shell))
+  active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
-    return;
 
-  gimp_display_shell_set_snap_to_canvas (shell, active);
+  if (active != gimp_display_shell_get_snap_to_canvas (shell))
+    {
+      gimp_display_shell_set_snap_to_canvas (shell, active);
+    }
 }
 
 void
@@ -598,13 +937,15 @@ view_snap_to_vectors_cmd_callback (GtkAction *action,
                                    gpointer   data)
 {
   GimpDisplayShell *shell;
-  gboolean          active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+  gboolean          active;
   return_if_no_shell (shell, data);
 
-  if (active == gimp_display_shell_get_snap_to_vectors (shell))
+  active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
-    return;
 
-  gimp_display_shell_set_snap_to_vectors (shell, active);
+  if (active != gimp_display_shell_get_snap_to_vectors (shell))
+    {
+      gimp_display_shell_set_snap_to_vectors (shell, active);
+    }
 }
 
 void
@@ -632,12 +973,14 @@ view_padding_color_cmd_callback (GtkAction *action,
   else
     options = shell->options;
 
+#define PADDING_COLOR_DIALOG_KEY "gimp-padding-color-dialog"
+
   switch ((GimpCanvasPaddingMode) value)
     {
     case GIMP_CANVAS_PADDING_MODE_DEFAULT:
     case GIMP_CANVAS_PADDING_MODE_LIGHT_CHECK:
     case GIMP_CANVAS_PADDING_MODE_DARK_CHECK:
-      g_object_set_data (G_OBJECT (shell), "padding-color-dialog", NULL);
+      dialogs_destroy_dialog (G_OBJECT (shell), PADDING_COLOR_DIALOG_KEY);
 
       options->padding_mode_set = TRUE;
 
@@ -647,17 +990,16 @@ view_padding_color_cmd_callback (GtkAction *action,
 
     case GIMP_CANVAS_PADDING_MODE_CUSTOM:
       {
-        GtkWidget *color_dialog;
+        GtkWidget *dialog;
 
-        color_dialog = g_object_get_data (G_OBJECT (shell),
+        dialog = dialogs_get_dialog (G_OBJECT (shell), PADDING_COLOR_DIALOG_KEY);
-                                          "padding-color-dialog");
 
-        if (! color_dialog)
+        if (! dialog)
           {
             GimpImage        *image = gimp_display_get_image (display);
             GimpDisplayShell *shell = gimp_display_get_shell (display);
 
-            color_dialog =
+            dialog =
               gimp_color_dialog_new (GIMP_VIEWABLE (image),
                                      action_data_get_context (data),
                                      _("Set Canvas Padding Color"),
@@ -668,21 +1010,20 @@ view_padding_color_cmd_callback (GtkAction *action,
                                      &options->padding_color,
                                      FALSE, FALSE);
 
-            g_signal_connect (color_dialog, "update",
+            g_signal_connect (dialog, "update",
                               G_CALLBACK (view_padding_color_dialog_update),
                               shell);
 
-            g_object_set_data_full (G_OBJECT (shell), "padding-color-dialog",
+            dialogs_attach_dialog (G_OBJECT (shell),
-                                    color_dialog,
+                                   PADDING_COLOR_DIALOG_KEY, dialog);
-                                    (GDestroyNotify) gtk_widget_destroy);
           }
 
-        gtk_window_present (GTK_WINDOW (color_dialog));
+        gtk_window_present (GTK_WINDOW (dialog));
       }
       break;
 
     case GIMP_CANVAS_PADDING_MODE_RESET:
-      g_object_set_data (G_OBJECT (shell), "padding-color-dialog", NULL);
+      dialogs_destroy_dialog (G_OBJECT (shell), PADDING_COLOR_DIALOG_KEY);
 
       {
         GimpDisplayOptions *default_options;
@@ -737,6 +1078,32 @@ view_fullscreen_cmd_callback (GtkAction *action,
 
 /*  private functions  */
 
+static void
+view_softproof_profile_callback (GtkWidget                *dialog,
+                                 GimpImage                *image,
+                                 GimpColorProfile         *new_profile,
+                                 GFile                    *new_file,
+                                 GimpColorRenderingIntent  intent,
+                                 gboolean                  bpc,
+                                 gpointer                  user_data)
+{
+  GimpDisplayShell *shell = user_data;
+  GimpColorConfig  *color_config;
+  gchar            *path  = NULL;
+
+  color_config = gimp_display_shell_get_color_config (shell);
+
+  if (new_file)
+    path = g_file_get_path (new_file);
+
+  g_object_set (color_config,
+                "printer-profile", path,
+                NULL);
+  shell->color_config_set = TRUE;
+
+  gtk_widget_destroy (dialog);
+}
+
 static void
 view_padding_color_dialog_update (GimpColorDialog      *dialog,
                                   const GimpRGB        *color,
@@ -769,7 +1136,7 @@ view_padding_color_dialog_update (GimpColorDialog      *dialog,
       /* fallthru */
 
     case GIMP_COLOR_DIALOG_CANCEL:
-      g_object_set_data (G_OBJECT (shell), "padding-color-dialog", NULL);
+      gtk_widget_destroy (GTK_WIDGET (dialog));
       break;
 
     default:

app/actions/view-commands.h

@@ -19,83 +19,113 @@
 #define __VIEW_COMMANDS_H__
 
 
-void   view_new_cmd_callback                   (GtkAction *action,
+void   view_new_cmd_callback                    (GtkAction *action,
-                                                gpointer   data);
+                                                 gpointer   data);
-void   view_close_cmd_callback                 (GtkAction *action,
+void   view_close_cmd_callback                  (GtkAction *action,
-                                                gpointer   data);
+                                                 gpointer   data);
 
-void   view_zoom_fit_in_cmd_callback           (GtkAction *action,
+void   view_zoom_fit_in_cmd_callback            (GtkAction *action,
-                                                gpointer   data);
+                                                 gpointer   data);
-void   view_zoom_fill_cmd_callback             (GtkAction *action,
+void   view_zoom_fill_cmd_callback              (GtkAction *action,
-                                                gpointer   data);
+                                                 gpointer   data);
-void   view_zoom_revert_cmd_callback           (GtkAction *action,
+void   view_zoom_selection_cmd_callback         (GtkAction *action,
-                                                gpointer   data);
+                                                 gpointer   data);
-void   view_zoom_cmd_callback                  (GtkAction *action,
+void   view_zoom_revert_cmd_callback            (GtkAction *action,
-                                                gint       value,
+                                                 gpointer   data);
-                                                gpointer   data);
+void   view_zoom_cmd_callback                   (GtkAction *action,
-void   view_zoom_explicit_cmd_callback         (GtkAction *action,
+                                                 gint       value,
-                                                GtkAction *current,
+                                                 gpointer   data);
-                                                gpointer   data);
+void   view_zoom_explicit_cmd_callback          (GtkAction *action,
-void   view_zoom_other_cmd_callback            (GtkAction *action,
+                                                 GtkAction *current,
-                                                gpointer   data);
+                                                 gpointer   data);
-void   view_dot_for_dot_cmd_callback           (GtkAction *action,
+void   view_zoom_other_cmd_callback             (GtkAction *action,
-                                                gpointer   data);
+                                                 gpointer   data);
+void   view_dot_for_dot_cmd_callback            (GtkAction *action,
+                                                 gpointer   data);
 
-void   view_scroll_horizontal_cmd_callback     (GtkAction *action,
+void   view_scroll_horizontal_cmd_callback      (GtkAction *action,
-                                                gint       value,
+                                                 gint       value,
-                                                gpointer   data);
+                                                 gpointer   data);
-void   view_scroll_vertical_cmd_callback       (GtkAction *action,
+void   view_scroll_vertical_cmd_callback        (GtkAction *action,
-                                                gint       value,
+                                                 gint       value,
-                                                gpointer   data);
+                                                 gpointer   data);
 
-void   view_rotate_absolute_cmd_callback       (GtkAction *action,
+void   view_flip_horizontally_cmd_callback      (GtkAction *action,
-                                                gint       value,
+                                                 gpointer   data);
-                                                gpointer   data);
+void   view_flip_vertically_cmd_callback        (GtkAction *action,
-void   view_rotate_relative_cmd_callback       (GtkAction *action,
+                                                 gpointer   data);
-                                                gint       value,
-                                                gpointer   data);
-void   view_rotate_other_cmd_callback          (GtkAction *action,
-                                                gpointer   data);
 
-void   view_navigation_window_cmd_callback     (GtkAction *action,
+void   view_rotate_absolute_cmd_callback        (GtkAction *action,
-                                                gpointer   data);
+                                                 gint       value,
-void   view_display_filters_cmd_callback       (GtkAction *action,
+                                                 gpointer   data);
-                                                gpointer   data);
+void   view_rotate_relative_cmd_callback        (GtkAction *action,
-void   view_toggle_selection_cmd_callback      (GtkAction *action,
+                                                 gint       value,
-                                                gpointer   data);
+                                                 gpointer   data);
-void   view_toggle_layer_boundary_cmd_callback (GtkAction *action,
+void   view_rotate_other_cmd_callback           (GtkAction *action,
-                                                gpointer   data);
+                                                 gpointer   data);
-void   view_toggle_menubar_cmd_callback        (GtkAction *action,
-                                                gpointer   data);
-void   view_toggle_rulers_cmd_callback         (GtkAction *action,
-                                                gpointer   data);
-void   view_toggle_scrollbars_cmd_callback     (GtkAction *action,
-                                                gpointer   data);
-void   view_toggle_statusbar_cmd_callback      (GtkAction *action,
-                                                gpointer   data);
-void   view_toggle_guides_cmd_callback         (GtkAction *action,
-                                                gpointer   data);
-void   view_toggle_grid_cmd_callback           (GtkAction *action,
-                                                gpointer   data);
-void   view_toggle_sample_points_cmd_callback  (GtkAction *action,
-                                                gpointer   data);
 
-void   view_snap_to_guides_cmd_callback        (GtkAction *action,
+void   view_navigation_window_cmd_callback      (GtkAction *action,
-                                                gpointer   data);
+                                                 gpointer   data);
-void   view_snap_to_grid_cmd_callback          (GtkAction *action,
+void   view_display_filters_cmd_callback        (GtkAction *action,
-                                                gpointer   data);
+                                                 gpointer   data);
-void   view_snap_to_canvas_cmd_callback        (GtkAction *action,
-                                                gpointer   data);
-void   view_snap_to_vectors_cmd_callback       (GtkAction *action,
-                                                gpointer   data);
-void   view_padding_color_cmd_callback         (GtkAction *action,
-                                                gint       value,
-                                                gpointer   data);
 
-void   view_shrink_wrap_cmd_callback           (GtkAction *action,
+void   view_color_management_reset_cmd_callback (GtkAction *action,
-                                                gpointer   data);
+                                                 gpointer   data);
-void   view_fullscreen_cmd_callback            (GtkAction *action,
+void   view_color_management_enable_cmd_callback(GtkAction *action,
-                                                gpointer   data);
+                                                 gpointer   data);
+void   view_color_management_softproof_cmd_callback
+                                                (GtkAction *action,
+                                                 gpointer   data);
+void   view_display_intent_cmd_callback         (GtkAction *action,
+                                                 GtkAction *current,
+                                                 gpointer   data);
+void   view_display_bpc_cmd_callback            (GtkAction *action,
+                                                 gpointer   data);
+void   view_softproof_profile_cmd_callback      (GtkAction *action,
+                                                 gpointer   data);
+void   view_softproof_intent_cmd_callback       (GtkAction *action,
+                                                 GtkAction *current,
+                                                 gpointer   data);
+void   view_softproof_bpc_cmd_callback          (GtkAction *action,
+                                                 gpointer   data);
+void   view_softproof_gamut_check_cmd_callback  (GtkAction *action,
+                                                 gpointer   data);
+
+void   view_toggle_selection_cmd_callback       (GtkAction *action,
+                                                 gpointer   data);
+void   view_toggle_layer_boundary_cmd_callback  (GtkAction *action,
+                                                 gpointer   data);
+void   view_toggle_menubar_cmd_callback         (GtkAction *action,
+                                                 gpointer   data);
+void   view_toggle_rulers_cmd_callback          (GtkAction *action,
+                                                 gpointer   data);
+void   view_toggle_scrollbars_cmd_callback      (GtkAction *action,
+                                                 gpointer   data);
+void   view_toggle_statusbar_cmd_callback       (GtkAction *action,
+                                                 gpointer   data);
+void   view_toggle_guides_cmd_callback          (GtkAction *action,
+                                                 gpointer   data);
+void   view_toggle_grid_cmd_callback            (GtkAction *action,
+                                                 gpointer   data);
+void   view_toggle_sample_points_cmd_callback   (GtkAction *action,
+                                                 gpointer   data);
+
+void   view_snap_to_guides_cmd_callback         (GtkAction *action,
+                                                 gpointer   data);
+void   view_snap_to_grid_cmd_callback           (GtkAction *action,
+                                                 gpointer   data);
+void   view_snap_to_canvas_cmd_callback         (GtkAction *action,
+                                                 gpointer   data);
+void   view_snap_to_vectors_cmd_callback        (GtkAction *action,
+                                                 gpointer   data);
+void   view_padding_color_cmd_callback          (GtkAction *action,
+                                                 gint       value,
+                                                 gpointer   data);
+
+void   view_shrink_wrap_cmd_callback            (GtkAction *action,
+                                                 gpointer   data);
+void   view_fullscreen_cmd_callback             (GtkAction *action,
+                                                 gpointer   data);
 
 
 #endif /* __VIEW_COMMANDS_H__ */

app/actions/windows-actions.c

@@ -222,7 +222,7 @@ windows_actions_setup (GimpActionGroup *group)
                            G_CALLBACK (windows_actions_recent_remove),
                            group, 0);
 
-  for (list = GIMP_LIST (global_recent_docks)->list;
+  for (list = GIMP_LIST (global_recent_docks)->queue->head;
        list;
        list = g_list_next (list))
     {

app/actions/windows-commands.c

@@ -53,16 +53,16 @@ void
 windows_hide_docks_cmd_callback (GtkAction *action,
                                  gpointer   data)
 {
-  gboolean  active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
   Gimp     *gimp;
+  gboolean  active;
   return_if_no_gimp (gimp, data);
 
-  if (GIMP_GUI_CONFIG (gimp->config)->hide_docks == active)
+  active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
-    return;
 
-  g_object_set (gimp->config,
+  if (active != GIMP_GUI_CONFIG (gimp->config)->hide_docks)
-                "hide-docks", active,
+    g_object_set (gimp->config,
-                NULL);
+                  "hide-docks", active,
+                  NULL);
 }
 
 void
@@ -70,32 +70,32 @@ windows_set_tabs_position_cmd_callback (GtkAction *action,
                                         GtkAction *current,
                                         gpointer   data)
 {
-  GimpPosition value = gtk_radio_action_get_current_value (GTK_RADIO_ACTION (action));
+  Gimp         *gimp;
-  Gimp     *gimp;
+  GimpPosition  value;
   return_if_no_gimp (gimp, data);
 
-  if (GIMP_GUI_CONFIG (gimp->config)->tabs_position == value)
+  value = gtk_radio_action_get_current_value (GTK_RADIO_ACTION (action));
-    return;
 
-  g_object_set (gimp->config,
+  if (value != GIMP_GUI_CONFIG (gimp->config)->tabs_position)
-                "tabs-position", value,
+    g_object_set (gimp->config,
-                NULL);
+                  "tabs-position", value,
+                  NULL);
 }
 
 void
 windows_use_single_window_mode_cmd_callback (GtkAction *action,
                                              gpointer   data)
 {
-  gboolean  active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
   Gimp     *gimp;
+  gboolean  active;
   return_if_no_gimp (gimp, data);
 
-  if (GIMP_GUI_CONFIG (gimp->config)->single_window_mode == active)
+  active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
-    return;
 
-  g_object_set (gimp->config,
+  if (active != GIMP_GUI_CONFIG (gimp->config)->single_window_mode)
-                "single-window-mode", active,
+    g_object_set (gimp->config,
-                NULL);
+                  "single-window-mode", active,
+                  NULL);
 }
 
 void

app/app.c

@@ -48,6 +48,7 @@
 #include "gegl/gimp-gegl.h"
 
 #include "core/gimp.h"
+#include "core/gimp-batch.h"
 #include "core/gimp-user-install.h"
 
 #include "file/file-open.h"
@@ -59,9 +60,7 @@
 #endif
 
 #include "app.h"
-#include "batch.h"
 #include "errors.h"
-#include "units.h"
 #include "language.h"
 #include "gimp-debug.h"
 
@@ -210,8 +209,6 @@ app_run (const gchar         *full_prog_name,
 
   errors_init (gimp, full_prog_name, use_debug_handler, stack_trace_mode);
 
-  units_init (gimp);
-
   /*  Check if the user's gimp_directory exists
    */
   gimpdir = gimp_directory_file (NULL);
@@ -219,7 +216,8 @@ app_run (const gchar         *full_prog_name,
   if (g_file_query_file_type (gimpdir, G_FILE_QUERY_INFO_NONE, NULL) !=
       G_FILE_TYPE_DIRECTORY)
     {
-      GimpUserInstall *install = gimp_user_install_new (be_verbose);
+      GimpUserInstall *install = gimp_user_install_new (G_OBJECT (gimp),
+                                                        be_verbose);
 
 #ifdef GIMP_CONSOLE_COMPILATION
       gimp_user_install_run (install);
@@ -301,7 +299,7 @@ app_run (const gchar         *full_prog_name,
     }
 
   if (run_loop)
-    batch_run (gimp, batch_interpreter, batch_commands);
+    gimp_batch_run (gimp, batch_interpreter, batch_commands);
 
   if (run_loop)
     {

app/config/Makefile.am

@@ -40,6 +40,8 @@ libappconfig_a_sources = \
 	gimpconfig-utils.h		\
 	gimpcoreconfig.c		\
 	gimpcoreconfig.h		\
+	gimpdialogconfig.c		\
+	gimpdialogconfig.h		\
 	gimpdisplayconfig.c		\
 	gimpdisplayconfig.h		\
 	gimpdisplayoptions.c		\
@@ -110,7 +112,6 @@ test_config_LDADD = \
 	$(libgimpmath)				\
 	$(libgimpconfig)			\
 	$(libgimpbase)				\
-	$(LCMS_LIBS)				\
 	$(PANGOCAIRO_LIBS)			\
 	$(HARFBUZZ_LIBS)			\
 	$(GDK_PIXBUF_LIBS)			\
@@ -119,7 +120,7 @@ test_config_LDADD = \
 	$(GEXIV2_LIBS)				\
 	$(Z_LIBS)				\
 	$(JSON_C_LIBS)				\
-	$(LIBMYPAINTGEGL_LIBS)		\
+	$(LIBMYPAINT_LIBS)		\
 	$(libm)
 
 CLEANFILES = $(EXTRA_PROGRAMS) foorc

app/config/config-types.h

@@ -35,6 +35,7 @@ typedef struct _GimpGeglConfig       GimpGeglConfig;
 typedef struct _GimpCoreConfig       GimpCoreConfig;
 typedef struct _GimpDisplayConfig    GimpDisplayConfig;
 typedef struct _GimpGuiConfig        GimpGuiConfig;
+typedef struct _GimpDialogConfig     GimpDialogConfig;
 typedef struct _GimpPluginConfig     GimpPluginConfig;
 typedef struct _GimpRc               GimpRc;
 

app/config/gimpconfig-dump.c

@@ -56,13 +56,18 @@ static void    dump_with_linebreaks (GOutputStream    *output,
 
 
 gboolean
-gimp_config_dump (GimpConfigDumpFormat  format)
+gimp_config_dump (GObject              *gimp,
+                  GimpConfigDumpFormat  format)
 {
   GOutputStream    *output;
   GimpConfigWriter *writer;
   GimpConfig       *rc;
 
-  rc = g_object_new (GIMP_TYPE_RC, NULL);
+  g_return_val_if_fail (G_IS_OBJECT (gimp), FALSE);
+
+  rc = g_object_new (GIMP_TYPE_RC,
+                     "gimp", gimp,
+                     NULL);
 
 #ifdef G_OS_WIN32
   output = g_win32_output_stream_new ((gpointer) 1, FALSE);

app/config/gimpconfig-dump.h

@@ -30,7 +30,8 @@ typedef enum
 } GimpConfigDumpFormat;
 
 
-gboolean  gimp_config_dump (GimpConfigDumpFormat  format);
+gboolean  gimp_config_dump (GObject              *gimp,
+                            GimpConfigDumpFormat  format);
 
 
 #endif  /* __GIMP_CONFIG_DUMP_H__ */

app/config/gimpconfig-utils.c

@@ -47,7 +47,7 @@ gimp_config_connect_notify (GObject    *src,
           (dest_spec->flags & G_PARAM_WRITABLE)             &&
           (dest_spec->flags & G_PARAM_CONSTRUCT_ONLY) == 0)
         {
-          GValue value = { 0, };
+          GValue value = G_VALUE_INIT;
 
           g_value_init (&value, param_spec->value_type);
 
@@ -128,7 +128,7 @@ gimp_config_connect_full_notify (GObject    *src,
           (dest_spec->flags & G_PARAM_WRITABLE)             &&
           (dest_spec->flags & G_PARAM_CONSTRUCT_ONLY) == 0)
         {
-          GValue value = { 0, };
+          GValue value = G_VALUE_INIT;
 
           g_value_init (&value, param_spec->value_type);
 

app/config/gimpcoreconfig.c

@@ -66,6 +66,8 @@ enum
   PROP_BRUSH_PATH_WRITABLE,
   PROP_DYNAMICS_PATH,
   PROP_DYNAMICS_PATH_WRITABLE,
+  PROP_MYPAINT_BRUSH_PATH,
+  PROP_MYPAINT_BRUSH_PATH_WRITABLE,
   PROP_PATTERN_PATH,
   PROP_PATTERN_PATH_WRITABLE,
   PROP_PALETTE_PATH,
@@ -76,16 +78,14 @@ enum
   PROP_TOOL_PRESET_PATH_WRITABLE,
   PROP_FONT_PATH,
   PROP_FONT_PATH_WRITABLE,
-  PROP_MYPAINT_BRUSH_PATH,
-  PROP_MYPAINT_BRUSH_PATH_WRITABLE,
   PROP_DEFAULT_BRUSH,
   PROP_DEFAULT_DYNAMICS,
+  PROP_DEFAULT_MYPAINT_BRUSH,
   PROP_DEFAULT_PATTERN,
   PROP_DEFAULT_PALETTE,
   PROP_DEFAULT_GRADIENT,
   PROP_DEFAULT_TOOL_PRESET,
   PROP_DEFAULT_FONT,
-  PROP_DEFAULT_MYPAINT_BRUSH,
   PROP_GLOBAL_BRUSH,
   PROP_GLOBAL_DYNAMICS,
   PROP_GLOBAL_PATTERN,
@@ -97,14 +97,13 @@ enum
   PROP_UNDO_LEVELS,
   PROP_UNDO_SIZE,
   PROP_UNDO_PREVIEW_SIZE,
-  PROP_PLUG_IN_HISTORY_SIZE,
+  PROP_FILTER_HISTORY_SIZE,
   PROP_PLUGINRC_PATH,
   PROP_LAYER_PREVIEWS,
   PROP_LAYER_PREVIEW_SIZE,
   PROP_THUMBNAIL_SIZE,
   PROP_THUMBNAIL_FILESIZE_LIMIT,
   PROP_COLOR_MANAGEMENT,
-  PROP_COLOR_PROFILE_POLICY,
   PROP_SAVE_DOCUMENT_HISTORY,
   PROP_QUICK_MASK_COLOR,
 
@@ -155,170 +154,109 @@ gimp_core_config_class_init (GimpCoreConfigClass *klass)
   object_class->set_property = gimp_core_config_set_property;
   object_class->get_property = gimp_core_config_get_property;
 
-  GIMP_CONFIG_INSTALL_PROP_STRING (object_class, PROP_LANGUAGE,
+  GIMP_CONFIG_PROP_STRING (object_class, PROP_LANGUAGE,
-                                   "language", LANGUAGE_BLURB,
+                           "language",
-                                   NULL,  /* take from environment */
+                           "Language",
-                                   GIMP_PARAM_STATIC_STRINGS |
+                           LANGUAGE_BLURB,
-                                   GIMP_CONFIG_PARAM_RESTART);
+                           NULL,  /* take from environment */
-  GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_INTERPOLATION_TYPE,
+                           GIMP_PARAM_STATIC_STRINGS |
-                                 "interpolation-type",
+                           GIMP_CONFIG_PARAM_RESTART);
-                                 INTERPOLATION_TYPE_BLURB,
+
-                                 GIMP_TYPE_INTERPOLATION_TYPE,
+  GIMP_CONFIG_PROP_ENUM (object_class, PROP_INTERPOLATION_TYPE,
-                                 GIMP_INTERPOLATION_CUBIC,
+                         "interpolation-type",
-                                 GIMP_PARAM_STATIC_STRINGS);
+                         "Interpolation",
-  GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_DEFAULT_THRESHOLD,
+                         INTERPOLATION_TYPE_BLURB,
-                                "default-threshold", DEFAULT_THRESHOLD_BLURB,
+                         GIMP_TYPE_INTERPOLATION_TYPE,
-                                0, 255, 15,
+                         GIMP_INTERPOLATION_CUBIC,
-                                GIMP_PARAM_STATIC_STRINGS);
+                         GIMP_PARAM_STATIC_STRINGS);
+
+  GIMP_CONFIG_PROP_INT (object_class, PROP_DEFAULT_THRESHOLD,
+                        "default-threshold",
+                        "Default threshold",
+                        DEFAULT_THRESHOLD_BLURB,
+                        0, 255, 15,
+                        GIMP_PARAM_STATIC_STRINGS);
 
   path = gimp_config_build_plug_in_path ("plug-ins");
-  GIMP_CONFIG_INSTALL_PROP_PATH (object_class, PROP_PLUG_IN_PATH,
+  GIMP_CONFIG_PROP_PATH (object_class, PROP_PLUG_IN_PATH,
-                                 "plug-in-path", PLUG_IN_PATH_BLURB,
+                         "plug-in-path",
-                                 GIMP_CONFIG_PATH_DIR_LIST, path,
+                         "Plug-In path",
-                                 GIMP_PARAM_STATIC_STRINGS |
+                         PLUG_IN_PATH_BLURB,
-                                 GIMP_CONFIG_PARAM_RESTART);
+                         GIMP_CONFIG_PATH_DIR_LIST, path,
+                         GIMP_PARAM_STATIC_STRINGS |
+                         GIMP_CONFIG_PARAM_RESTART);
   g_free (path);
 
   path = gimp_config_build_plug_in_path ("modules");
-  GIMP_CONFIG_INSTALL_PROP_PATH (object_class, PROP_MODULE_PATH,
+  GIMP_CONFIG_PROP_PATH (object_class, PROP_MODULE_PATH,
-                                 "module-path", MODULE_PATH_BLURB,
+                         "module-path",
-                                 GIMP_CONFIG_PATH_DIR_LIST, path,
+                         "Module path",
-                                 GIMP_PARAM_STATIC_STRINGS |
+                         MODULE_PATH_BLURB,
-                                 GIMP_CONFIG_PARAM_RESTART);
+                         GIMP_CONFIG_PATH_DIR_LIST, path,
+                         GIMP_PARAM_STATIC_STRINGS |
+                         GIMP_CONFIG_PARAM_RESTART);
   g_free (path);
 
   path = gimp_config_build_plug_in_path ("interpreters");
-  GIMP_CONFIG_INSTALL_PROP_PATH (object_class, PROP_INTERPRETER_PATH,
+  GIMP_CONFIG_PROP_PATH (object_class, PROP_INTERPRETER_PATH,
-                                 "interpreter-path", INTERPRETER_PATH_BLURB,
+                         "interpreter-path",
-                                 GIMP_CONFIG_PATH_DIR_LIST, path,
+                         "Interpreter path",
-                                 GIMP_PARAM_STATIC_STRINGS |
+                         INTERPRETER_PATH_BLURB,
-                                 GIMP_CONFIG_PARAM_RESTART);
+                         GIMP_CONFIG_PATH_DIR_LIST, path,
+                         GIMP_PARAM_STATIC_STRINGS |
+                         GIMP_CONFIG_PARAM_RESTART);
   g_free (path);
 
   path = gimp_config_build_plug_in_path ("environ");
-  GIMP_CONFIG_INSTALL_PROP_PATH (object_class, PROP_ENVIRON_PATH,
+  GIMP_CONFIG_PROP_PATH (object_class, PROP_ENVIRON_PATH,
-                                 "environ-path", ENVIRON_PATH_BLURB,
+                         "environ-path",
-                                 GIMP_CONFIG_PATH_DIR_LIST, path,
+                         "Environment path",
-                                 GIMP_PARAM_STATIC_STRINGS |
+                         ENVIRON_PATH_BLURB,
-                                 GIMP_CONFIG_PARAM_RESTART);
+                         GIMP_CONFIG_PATH_DIR_LIST, path,
+                         GIMP_PARAM_STATIC_STRINGS |
+                         GIMP_CONFIG_PARAM_RESTART);
   g_free (path);
 
   path = gimp_config_build_data_path ("brushes");
-  GIMP_CONFIG_INSTALL_PROP_PATH (object_class, PROP_BRUSH_PATH,
+  GIMP_CONFIG_PROP_PATH (object_class, PROP_BRUSH_PATH,
-                                 "brush-path", BRUSH_PATH_BLURB,
+                         "brush-path",
-                                 GIMP_CONFIG_PATH_DIR_LIST, path,
+                         "Brush path",
-                                 GIMP_PARAM_STATIC_STRINGS |
+                         BRUSH_PATH_BLURB,
-                                 GIMP_CONFIG_PARAM_RESTART);
+                         GIMP_CONFIG_PATH_DIR_LIST, path,
+                         GIMP_PARAM_STATIC_STRINGS |
+                         GIMP_CONFIG_PARAM_RESTART);
   g_free (path);
 
   path = gimp_config_build_writable_path ("brushes");
-  GIMP_CONFIG_INSTALL_PROP_PATH (object_class, PROP_BRUSH_PATH_WRITABLE,
+  GIMP_CONFIG_PROP_PATH (object_class, PROP_BRUSH_PATH_WRITABLE,
-                                 "brush-path-writable",
+                         "brush-path-writable",
-                                 BRUSH_PATH_WRITABLE_BLURB,
+                         "Writable brush path",
-                                 GIMP_CONFIG_PATH_DIR_LIST, path,
+                         BRUSH_PATH_WRITABLE_BLURB,
-                                 GIMP_PARAM_STATIC_STRINGS |
+                         GIMP_CONFIG_PATH_DIR_LIST, path,
-                                 GIMP_CONFIG_PARAM_RESTART);
+                         GIMP_PARAM_STATIC_STRINGS |
+                         GIMP_CONFIG_PARAM_RESTART);
   g_free (path);
 
   path = gimp_config_build_data_path ("dynamics");
-  GIMP_CONFIG_INSTALL_PROP_PATH (object_class, PROP_DYNAMICS_PATH,
+  GIMP_CONFIG_PROP_PATH (object_class, PROP_DYNAMICS_PATH,
-                                 "dynamics-path", DYNAMICS_PATH_BLURB,
+                         "dynamics-path",
-                                 GIMP_CONFIG_PATH_DIR_LIST, path,
+                         "Dynamics path",
-                                 GIMP_PARAM_STATIC_STRINGS |
+                         DYNAMICS_PATH_BLURB,
-                                 GIMP_CONFIG_PARAM_RESTART);
+                         GIMP_CONFIG_PATH_DIR_LIST, path,
+                         GIMP_PARAM_STATIC_STRINGS |
+                         GIMP_CONFIG_PARAM_RESTART);
   g_free (path);
 
   path = gimp_config_build_writable_path ("dynamics");
-  GIMP_CONFIG_INSTALL_PROP_PATH (object_class, PROP_DYNAMICS_PATH_WRITABLE,
+  GIMP_CONFIG_PROP_PATH (object_class, PROP_DYNAMICS_PATH_WRITABLE,
-                                 "dynamics-path-writable",
+                         "dynamics-path-writable",
-                                 DYNAMICS_PATH_WRITABLE_BLURB,
+                         "Writable dynamics path",
-                                 GIMP_CONFIG_PATH_DIR_LIST, path,
+                         DYNAMICS_PATH_WRITABLE_BLURB,
-                                 GIMP_PARAM_STATIC_STRINGS |
+                         GIMP_CONFIG_PATH_DIR_LIST, path,
-                                 GIMP_CONFIG_PARAM_RESTART);
+                         GIMP_PARAM_STATIC_STRINGS |
+                         GIMP_CONFIG_PARAM_RESTART);
   g_free (path);
 
-  path = gimp_config_build_data_path ("patterns");
-  GIMP_CONFIG_INSTALL_PROP_PATH (object_class, PROP_PATTERN_PATH,
-                                 "pattern-path", PATTERN_PATH_BLURB,
-                                 GIMP_CONFIG_PATH_DIR_LIST, path,
-                                 GIMP_PARAM_STATIC_STRINGS |
-                                 GIMP_CONFIG_PARAM_RESTART);
-  g_free (path);
-
-  path = gimp_config_build_writable_path ("patterns");
-  GIMP_CONFIG_INSTALL_PROP_PATH (object_class, PROP_PATTERN_PATH_WRITABLE,
-                                 "pattern-path-writable",
-                                 PATTERN_PATH_WRITABLE_BLURB,
-                                 GIMP_CONFIG_PATH_DIR_LIST, path,
-                                 GIMP_PARAM_STATIC_STRINGS |
-                                 GIMP_CONFIG_PARAM_RESTART);
-  g_free (path);
-
-  path = gimp_config_build_data_path ("palettes");
-  GIMP_CONFIG_INSTALL_PROP_PATH (object_class, PROP_PALETTE_PATH,
-                                 "palette-path", PALETTE_PATH_BLURB,
-                                 GIMP_CONFIG_PATH_DIR_LIST, path,
-                                 GIMP_PARAM_STATIC_STRINGS |
-                                 GIMP_CONFIG_PARAM_RESTART);
-  g_free (path);
-
-  path = gimp_config_build_writable_path ("palettes");
-  GIMP_CONFIG_INSTALL_PROP_PATH (object_class, PROP_PALETTE_PATH_WRITABLE,
-                                 "palette-path-writable",
-                                 PALETTE_PATH_WRITABLE_BLURB,
-                                 GIMP_CONFIG_PATH_DIR_LIST, path,
-                                 GIMP_PARAM_STATIC_STRINGS |
-                                 GIMP_CONFIG_PARAM_RESTART);
-  g_free (path);
-
-  path = gimp_config_build_data_path ("gradients");
-  GIMP_CONFIG_INSTALL_PROP_PATH (object_class, PROP_GRADIENT_PATH,
-                                 "gradient-path", GRADIENT_PATH_BLURB,
-                                 GIMP_CONFIG_PATH_DIR_LIST, path,
-                                 GIMP_PARAM_STATIC_STRINGS |
-                                 GIMP_CONFIG_PARAM_RESTART);
-  g_free (path);
-
-  path = gimp_config_build_writable_path ("gradients");
-  GIMP_CONFIG_INSTALL_PROP_PATH (object_class, PROP_GRADIENT_PATH_WRITABLE,
-                                 "gradient-path-writable",
-                                 GRADIENT_PATH_WRITABLE_BLURB,
-                                 GIMP_CONFIG_PATH_DIR_LIST, path,
-                                 GIMP_PARAM_STATIC_STRINGS |
-                                 GIMP_CONFIG_PARAM_RESTART);
-  g_free (path);
-
-  path = gimp_config_build_data_path ("tool-presets");
-  GIMP_CONFIG_INSTALL_PROP_PATH (object_class, PROP_TOOL_PRESET_PATH,
-                                 "tool-preset-path", TOOL_PRESET_PATH_BLURB,
-                                 GIMP_CONFIG_PATH_DIR_LIST, path,
-                                 GIMP_PARAM_STATIC_STRINGS |
-                                 GIMP_CONFIG_PARAM_RESTART);
-  g_free (path);
-
-  path = gimp_config_build_writable_path ("tool-presets");
-  GIMP_CONFIG_INSTALL_PROP_PATH (object_class, PROP_TOOL_PRESET_PATH_WRITABLE,
-                                 "tool-preset-path-writable",
-                                 TOOL_PRESET_PATH_WRITABLE_BLURB,
-                                 GIMP_CONFIG_PATH_DIR_LIST, path,
-                                 GIMP_PARAM_STATIC_STRINGS |
-                                 GIMP_CONFIG_PARAM_RESTART);
-  g_free (path);
-
-  path = gimp_config_build_data_path ("fonts");
-  GIMP_CONFIG_INSTALL_PROP_PATH (object_class, PROP_FONT_PATH,
-                                 "font-path", FONT_PATH_BLURB,
-                                 GIMP_CONFIG_PATH_DIR_LIST, path,
-                                 GIMP_PARAM_STATIC_STRINGS |
-                                 GIMP_CONFIG_PARAM_CONFIRM);
-  g_free (path);
-
-  GIMP_CONFIG_INSTALL_PROP_PATH (object_class, PROP_FONT_PATH_WRITABLE,
-                                 "font-path-writable", NULL,
-                                 GIMP_CONFIG_PATH_DIR_LIST, NULL,
-                                 GIMP_PARAM_STATIC_STRINGS |
-                                 GIMP_CONFIG_PARAM_IGNORE);
-
 #if 0
   /* FIXME these are useful dirs, disabled until we figure how to
    * properly generate a default gimprc
@@ -335,11 +273,13 @@ gimp_core_config_class_init (GimpCoreConfigClass *klass)
 #endif
                        "~/.mypaint/brushes",
                        NULL);
-  GIMP_CONFIG_INSTALL_PROP_PATH (object_class, PROP_MYPAINT_BRUSH_PATH,
+  GIMP_CONFIG_PROP_PATH (object_class, PROP_MYPAINT_BRUSH_PATH,
-                                 "mypaint-brush-path", MYPAINT_BRUSH_PATH_BLURB,
+                         "mypaint-brush-path",
-                                 GIMP_CONFIG_PATH_DIR_LIST, path,
+                         "MyPaint brush path",
-                                 GIMP_PARAM_STATIC_STRINGS |
+                         MYPAINT_BRUSH_PATH_BLURB,
-                                 GIMP_CONFIG_PARAM_RESTART);
+                         GIMP_CONFIG_PATH_DIR_LIST, path,
+                         GIMP_PARAM_STATIC_STRINGS |
+                         GIMP_CONFIG_PARAM_RESTART);
   g_free (path);
 #if 0
   g_free (dir1);
@@ -352,89 +292,237 @@ gimp_core_config_class_init (GimpCoreConfigClass *klass)
 #endif
                        "~/.mypaint/brushes",
                        NULL);
-  GIMP_CONFIG_INSTALL_PROP_PATH (object_class, PROP_MYPAINT_BRUSH_PATH_WRITABLE,
+  GIMP_CONFIG_PROP_PATH (object_class, PROP_MYPAINT_BRUSH_PATH_WRITABLE,
-                                 "mypaint-brush-path-writable",
+                         "mypaint-brush-path-writable",
-                                 MYPAINT_BRUSH_PATH_WRITABLE_BLURB,
+                         "Writable MyPaint brush path",
-                                 GIMP_CONFIG_PATH_DIR_LIST, path,
+                         MYPAINT_BRUSH_PATH_WRITABLE_BLURB,
-                                 GIMP_PARAM_STATIC_STRINGS |
+                         GIMP_CONFIG_PATH_DIR_LIST, path,
-                                 GIMP_CONFIG_PARAM_RESTART);
+                         GIMP_PARAM_STATIC_STRINGS |
+                         GIMP_CONFIG_PARAM_RESTART);
   g_free (path);
 #if 0
   g_free (dir2);
 #endif
 
-  GIMP_CONFIG_INSTALL_PROP_STRING (object_class, PROP_DEFAULT_BRUSH,
+  path = gimp_config_build_data_path ("patterns");
-                                   "default-brush", DEFAULT_BRUSH_BLURB,
+  GIMP_CONFIG_PROP_PATH (object_class, PROP_PATTERN_PATH,
-                                   DEFAULT_BRUSH,
+                         "pattern-path",
-                                   GIMP_PARAM_STATIC_STRINGS);
+                         "Pattern path",
-  GIMP_CONFIG_INSTALL_PROP_STRING (object_class, PROP_DEFAULT_DYNAMICS,
+                         PATTERN_PATH_BLURB,
-                                   "default-dynamics", DEFAULT_DYNAMICS_BLURB,
+                         GIMP_CONFIG_PATH_DIR_LIST, path,
-                                   DEFAULT_DYNAMICS,
+                         GIMP_PARAM_STATIC_STRINGS |
-                                   GIMP_PARAM_STATIC_STRINGS);
+                         GIMP_CONFIG_PARAM_RESTART);
-  GIMP_CONFIG_INSTALL_PROP_STRING (object_class, PROP_DEFAULT_PATTERN,
+  g_free (path);
-                                   "default-pattern", DEFAULT_PATTERN_BLURB,
-                                   DEFAULT_PATTERN,
-                                   GIMP_PARAM_STATIC_STRINGS);
-  GIMP_CONFIG_INSTALL_PROP_STRING (object_class, PROP_DEFAULT_PALETTE,
-                                   "default-palette", DEFAULT_PALETTE_BLURB,
-                                   DEFAULT_PALETTE,
-                                   GIMP_PARAM_STATIC_STRINGS);
-  GIMP_CONFIG_INSTALL_PROP_STRING (object_class, PROP_DEFAULT_GRADIENT,
-                                   "default-gradient", DEFAULT_GRADIENT_BLURB,
-                                   DEFAULT_GRADIENT,
-                                   GIMP_PARAM_STATIC_STRINGS);
-  GIMP_CONFIG_INSTALL_PROP_STRING (object_class, PROP_DEFAULT_TOOL_PRESET,
-                                   "default-tool-preset", DEFAULT_TOOL_PRESET_BLURB,
-                                   DEFAULT_TOOL_PRESET,
-                                   GIMP_PARAM_STATIC_STRINGS);
-  GIMP_CONFIG_INSTALL_PROP_STRING (object_class, PROP_DEFAULT_FONT,
-                                   "default-font", DEFAULT_FONT_BLURB,
-                                   DEFAULT_FONT,
-                                   GIMP_PARAM_STATIC_STRINGS);
-  GIMP_CONFIG_INSTALL_PROP_STRING (object_class, PROP_DEFAULT_MYPAINT_BRUSH,
-                                   "default-mypaint-brush", DEFAULT_MYPAINT_BRUSH_BLURB,
-                                   DEFAULT_MYPAINT_BRUSH,
-                                   GIMP_PARAM_STATIC_STRINGS);
 
-  GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_GLOBAL_BRUSH,
+  path = gimp_config_build_writable_path ("patterns");
-                                    "global-brush", GLOBAL_BRUSH_BLURB,
+  GIMP_CONFIG_PROP_PATH (object_class, PROP_PATTERN_PATH_WRITABLE,
-                                    TRUE,
+                         "pattern-path-writable",
-                                    GIMP_PARAM_STATIC_STRINGS);
+                         "Writable pattern path",
-  GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_GLOBAL_DYNAMICS,
+                         PATTERN_PATH_WRITABLE_BLURB,
-                                    "global-dynamics", GLOBAL_DYNAMICS_BLURB,
+                         GIMP_CONFIG_PATH_DIR_LIST, path,
-                                    TRUE,
+                         GIMP_PARAM_STATIC_STRINGS |
-                                    GIMP_PARAM_STATIC_STRINGS);
+                         GIMP_CONFIG_PARAM_RESTART);
-  GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_GLOBAL_PATTERN,
+  g_free (path);
-                                    "global-pattern", GLOBAL_PATTERN_BLURB,
+
-                                    TRUE,
+  path = gimp_config_build_data_path ("palettes");
-                                    GIMP_PARAM_STATIC_STRINGS);
+  GIMP_CONFIG_PROP_PATH (object_class, PROP_PALETTE_PATH,
-  GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_GLOBAL_PALETTE,
+                         "palette-path",
-                                    "global-palette", GLOBAL_PALETTE_BLURB,
+                         "Palette path",
-                                    TRUE,
+                         PALETTE_PATH_BLURB,
-                                    GIMP_PARAM_STATIC_STRINGS);
+                         GIMP_CONFIG_PATH_DIR_LIST, path,
-  GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_GLOBAL_GRADIENT,
+                         GIMP_PARAM_STATIC_STRINGS |
-                                    "global-gradient", GLOBAL_GRADIENT_BLURB,
+                         GIMP_CONFIG_PARAM_RESTART);
-                                    TRUE,
+  g_free (path);
-                                    GIMP_PARAM_STATIC_STRINGS);
+
-  GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_GLOBAL_FONT,
+  path = gimp_config_build_writable_path ("palettes");
-                                    "global-font", GLOBAL_FONT_BLURB,
+  GIMP_CONFIG_PROP_PATH (object_class, PROP_PALETTE_PATH_WRITABLE,
-                                    TRUE,
+                         "palette-path-writable",
-                                    GIMP_PARAM_STATIC_STRINGS);
+                         "Writable palette path",
-  GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_DEFAULT_IMAGE,
+                         PALETTE_PATH_WRITABLE_BLURB,
-                                   "default-image", DEFAULT_IMAGE_BLURB,
+                         GIMP_CONFIG_PATH_DIR_LIST, path,
-                                   GIMP_TYPE_TEMPLATE,
+                         GIMP_PARAM_STATIC_STRINGS |
-                                   GIMP_PARAM_STATIC_STRINGS |
+                         GIMP_CONFIG_PARAM_RESTART);
-                                   GIMP_CONFIG_PARAM_AGGREGATE);
+  g_free (path);
-  GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_DEFAULT_GRID,
+
-                                   "default-grid", DEFAULT_GRID_BLURB,
+  path = gimp_config_build_data_path ("gradients");
-                                   GIMP_TYPE_GRID,
+  GIMP_CONFIG_PROP_PATH (object_class, PROP_GRADIENT_PATH,
-                                   GIMP_PARAM_STATIC_STRINGS |
+                         "gradient-path",
-                                   GIMP_CONFIG_PARAM_AGGREGATE);
+                         "Gradient path",
-  GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_UNDO_LEVELS,
+                         GRADIENT_PATH_BLURB,
-                                "undo-levels", UNDO_LEVELS_BLURB,
+                         GIMP_CONFIG_PATH_DIR_LIST, path,
-                                0, 1 << 20, 5,
+                         GIMP_PARAM_STATIC_STRINGS |
-                                GIMP_PARAM_STATIC_STRINGS |
+                         GIMP_CONFIG_PARAM_RESTART);
-                                GIMP_CONFIG_PARAM_CONFIRM);
+  g_free (path);
+
+  path = gimp_config_build_writable_path ("gradients");
+  GIMP_CONFIG_PROP_PATH (object_class, PROP_GRADIENT_PATH_WRITABLE,
+                         "gradient-path-writable",
+                         "Writable gradient path",
+                         GRADIENT_PATH_WRITABLE_BLURB,
+                         GIMP_CONFIG_PATH_DIR_LIST, path,
+                         GIMP_PARAM_STATIC_STRINGS |
+                         GIMP_CONFIG_PARAM_RESTART);
+  g_free (path);
+
+  path = gimp_config_build_data_path ("tool-presets");
+  GIMP_CONFIG_PROP_PATH (object_class, PROP_TOOL_PRESET_PATH,
+                         "tool-preset-path",
+                         "Tool preset path",
+                         TOOL_PRESET_PATH_BLURB,
+                         GIMP_CONFIG_PATH_DIR_LIST, path,
+                         GIMP_PARAM_STATIC_STRINGS |
+                         GIMP_CONFIG_PARAM_RESTART);
+  g_free (path);
+
+  path = gimp_config_build_writable_path ("tool-presets");
+  GIMP_CONFIG_PROP_PATH (object_class, PROP_TOOL_PRESET_PATH_WRITABLE,
+                         "tool-preset-path-writable",
+                         "Writable tool preset path",
+                         TOOL_PRESET_PATH_WRITABLE_BLURB,
+                         GIMP_CONFIG_PATH_DIR_LIST, path,
+                         GIMP_PARAM_STATIC_STRINGS |
+                         GIMP_CONFIG_PARAM_RESTART);
+  g_free (path);
+
+  path = gimp_config_build_data_path ("fonts");
+  GIMP_CONFIG_PROP_PATH (object_class, PROP_FONT_PATH,
+                         "font-path",
+                         "Font path",
+                         FONT_PATH_BLURB,
+                         GIMP_CONFIG_PATH_DIR_LIST, path,
+                         GIMP_PARAM_STATIC_STRINGS |
+                         GIMP_CONFIG_PARAM_CONFIRM);
+  g_free (path);
+
+  GIMP_CONFIG_PROP_PATH (object_class, PROP_FONT_PATH_WRITABLE,
+                         "font-path-writable",
+                         "Writable font path",
+                         NULL,
+                         GIMP_CONFIG_PATH_DIR_LIST, NULL,
+                         GIMP_PARAM_STATIC_STRINGS |
+                         GIMP_CONFIG_PARAM_IGNORE);
+
+  GIMP_CONFIG_PROP_STRING (object_class, PROP_DEFAULT_BRUSH,
+                           "default-brush",
+                           "Default brush",
+                           DEFAULT_BRUSH_BLURB,
+                           DEFAULT_BRUSH,
+                           GIMP_PARAM_STATIC_STRINGS);
+
+  GIMP_CONFIG_PROP_STRING (object_class, PROP_DEFAULT_DYNAMICS,
+                           "default-dynamics",
+                           "Default dynamics",
+                           DEFAULT_DYNAMICS_BLURB,
+                           DEFAULT_DYNAMICS,
+                           GIMP_PARAM_STATIC_STRINGS);
+
+  GIMP_CONFIG_PROP_STRING (object_class, PROP_DEFAULT_MYPAINT_BRUSH,
+                           "default-mypaint-brush",
+                           "Default MyPaint brush",
+                           DEFAULT_MYPAINT_BRUSH_BLURB,
+                           DEFAULT_MYPAINT_BRUSH,
+                           GIMP_PARAM_STATIC_STRINGS);
+
+  GIMP_CONFIG_PROP_STRING (object_class, PROP_DEFAULT_PATTERN,
+                           "default-pattern",
+                           "Default pattern",
+                           DEFAULT_PATTERN_BLURB,
+                           DEFAULT_PATTERN,
+                           GIMP_PARAM_STATIC_STRINGS);
+
+  GIMP_CONFIG_PROP_STRING (object_class, PROP_DEFAULT_PALETTE,
+                           "default-palette",
+                           "Default palette",
+                           DEFAULT_PALETTE_BLURB,
+                           DEFAULT_PALETTE,
+                           GIMP_PARAM_STATIC_STRINGS);
+
+  GIMP_CONFIG_PROP_STRING (object_class, PROP_DEFAULT_GRADIENT,
+                           "default-gradient",
+                           "Default gradient",
+                           DEFAULT_GRADIENT_BLURB,
+                           DEFAULT_GRADIENT,
+                           GIMP_PARAM_STATIC_STRINGS);
+
+  GIMP_CONFIG_PROP_STRING (object_class, PROP_DEFAULT_TOOL_PRESET,
+                           "default-tool-preset",
+                           "Default tool preset",
+                           DEFAULT_TOOL_PRESET_BLURB,
+                           DEFAULT_TOOL_PRESET,
+                           GIMP_PARAM_STATIC_STRINGS);
+
+  GIMP_CONFIG_PROP_STRING (object_class, PROP_DEFAULT_FONT,
+                           "default-font",
+                           "Default font",
+                           DEFAULT_FONT_BLURB,
+                           DEFAULT_FONT,
+                           GIMP_PARAM_STATIC_STRINGS);
+
+  GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_GLOBAL_BRUSH,
+                            "global-brush",
+                            "Global brush",
+                            GLOBAL_BRUSH_BLURB,
+                            TRUE,
+                            GIMP_PARAM_STATIC_STRINGS);
+
+  GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_GLOBAL_DYNAMICS,
+                            "global-dynamics",
+                            "Global dynamics",
+                            GLOBAL_DYNAMICS_BLURB,
+                            TRUE,
+                            GIMP_PARAM_STATIC_STRINGS);
+
+  GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_GLOBAL_PATTERN,
+                            "global-pattern",
+                            "Global pattern",
+                            GLOBAL_PATTERN_BLURB,
+                            TRUE,
+                            GIMP_PARAM_STATIC_STRINGS);
+
+  GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_GLOBAL_PALETTE,
+                            "global-palette",
+                            "Global palette",
+                            GLOBAL_PALETTE_BLURB,
+                            TRUE,
+                            GIMP_PARAM_STATIC_STRINGS);
+
+  GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_GLOBAL_GRADIENT,
+                            "global-gradient",
+                            "Global gradient",
+                            GLOBAL_GRADIENT_BLURB,
+                            TRUE,
+                            GIMP_PARAM_STATIC_STRINGS);
+
+  GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_GLOBAL_FONT,
+                            "global-font",
+                            "Global font",
+                            GLOBAL_FONT_BLURB,
+                            TRUE,
+                            GIMP_PARAM_STATIC_STRINGS);
+
+  GIMP_CONFIG_PROP_OBJECT (object_class, PROP_DEFAULT_IMAGE,
+                           "default-image",
+                           "Default image",
+                           DEFAULT_IMAGE_BLURB,
+                           GIMP_TYPE_TEMPLATE,
+                           GIMP_PARAM_STATIC_STRINGS |
+                           GIMP_CONFIG_PARAM_AGGREGATE);
+
+  GIMP_CONFIG_PROP_OBJECT (object_class, PROP_DEFAULT_GRID,
+                           "default-grid",
+                           "Default grid",
+                           DEFAULT_GRID_BLURB,
+                           GIMP_TYPE_GRID,
+                           GIMP_PARAM_STATIC_STRINGS |
+                           GIMP_CONFIG_PARAM_AGGREGATE);
+
+  GIMP_CONFIG_PROP_INT (object_class, PROP_UNDO_LEVELS,
+                        "undo-levels",
+                        "Undo levels",
+                        UNDO_LEVELS_BLURB,
+                        0, 1 << 20, 5,
+                        GIMP_PARAM_STATIC_STRINGS |
+                        GIMP_CONFIG_PARAM_CONFIRM);
 
   undo_size = gimp_get_physical_memory_size ();
 
@@ -443,81 +531,107 @@ gimp_core_config_class_init (GimpCoreConfigClass *klass)
   else
     undo_size = 1 << 26; /* 64GB */
 
-  GIMP_CONFIG_INSTALL_PROP_MEMSIZE (object_class, PROP_UNDO_SIZE,
+  GIMP_CONFIG_PROP_MEMSIZE (object_class, PROP_UNDO_SIZE,
-                                    "undo-size", UNDO_SIZE_BLURB,
+                            "undo-size",
-                                    0, GIMP_MAX_MEMSIZE, undo_size,
+                            "Undo size",
-                                    GIMP_PARAM_STATIC_STRINGS |
+                            UNDO_SIZE_BLURB,
-                                    GIMP_CONFIG_PARAM_CONFIRM);
+                            0, GIMP_MAX_MEMSIZE, undo_size,
-  GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_UNDO_PREVIEW_SIZE,
+                            GIMP_PARAM_STATIC_STRINGS |
-                                 "undo-preview-size", UNDO_PREVIEW_SIZE_BLURB,
+                            GIMP_CONFIG_PARAM_CONFIRM);
-                                 GIMP_TYPE_VIEW_SIZE,
+
-                                 GIMP_VIEW_SIZE_LARGE,
+  GIMP_CONFIG_PROP_ENUM (object_class, PROP_UNDO_PREVIEW_SIZE,
-                                 GIMP_PARAM_STATIC_STRINGS |
+                         "undo-preview-size",
-                                 GIMP_CONFIG_PARAM_RESTART);
+                         "Undo preview size",
-  GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_PLUG_IN_HISTORY_SIZE,
+                         UNDO_PREVIEW_SIZE_BLURB,
-                                "plug-in-history-size",
+                         GIMP_TYPE_VIEW_SIZE,
-                                PLUG_IN_HISTORY_SIZE_BLURB,
+                         GIMP_VIEW_SIZE_LARGE,
-                                0, 256, 10,
+                         GIMP_PARAM_STATIC_STRINGS |
-                                GIMP_PARAM_STATIC_STRINGS |
+                         GIMP_CONFIG_PARAM_RESTART);
-                                GIMP_CONFIG_PARAM_RESTART);
+
-  GIMP_CONFIG_INSTALL_PROP_PATH (object_class,
+  GIMP_CONFIG_PROP_INT (object_class, PROP_FILTER_HISTORY_SIZE,
-                                 PROP_PLUGINRC_PATH,
+                        "plug-in-history-size", /* compat name */
-                                 "pluginrc-path", PLUGINRC_PATH_BLURB,
+                        "Filter history size",
-                                 GIMP_CONFIG_PATH_FILE,
+                        FILTER_HISTORY_SIZE_BLURB,
-                                 "${gimp_dir}" G_DIR_SEPARATOR_S "pluginrc",
+                        0, 256, 10,
-                                 GIMP_PARAM_STATIC_STRINGS |
+                        GIMP_PARAM_STATIC_STRINGS |
-                                 GIMP_CONFIG_PARAM_RESTART);
+                        GIMP_CONFIG_PARAM_RESTART);
-  GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_LAYER_PREVIEWS,
+
-                                    "layer-previews", LAYER_PREVIEWS_BLURB,
+  GIMP_CONFIG_PROP_PATH (object_class,
-                                    TRUE,
+                         PROP_PLUGINRC_PATH,
-                                    GIMP_PARAM_STATIC_STRINGS);
+                         "pluginrc-path",
-  GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_LAYER_PREVIEW_SIZE,
+                         "plugninrc path",
-                                 "layer-preview-size", LAYER_PREVIEW_SIZE_BLURB,
+                         PLUGINRC_PATH_BLURB,
-                                 GIMP_TYPE_VIEW_SIZE,
+                         GIMP_CONFIG_PATH_FILE,
-                                 GIMP_VIEW_SIZE_MEDIUM,
+                         "${gimp_dir}" G_DIR_SEPARATOR_S "pluginrc",
-                                 GIMP_PARAM_STATIC_STRINGS);
+                         GIMP_PARAM_STATIC_STRINGS |
-  GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_THUMBNAIL_SIZE,
+                         GIMP_CONFIG_PARAM_RESTART);
-                                 "thumbnail-size", THUMBNAIL_SIZE_BLURB,
+
-                                 GIMP_TYPE_THUMBNAIL_SIZE,
+  GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_LAYER_PREVIEWS,
-                                 GIMP_THUMBNAIL_SIZE_NORMAL,
+                            "layer-previews",
-                                 GIMP_PARAM_STATIC_STRINGS);
+                            "Layer previews",
-  GIMP_CONFIG_INSTALL_PROP_MEMSIZE (object_class, PROP_THUMBNAIL_FILESIZE_LIMIT,
+                            LAYER_PREVIEWS_BLURB,
-                                    "thumbnail-filesize-limit",
+                            TRUE,
-                                    THUMBNAIL_FILESIZE_LIMIT_BLURB,
+                            GIMP_PARAM_STATIC_STRINGS);
-                                    0, GIMP_MAX_MEMSIZE, 1 << 22,
+
-                                    GIMP_PARAM_STATIC_STRINGS);
+  GIMP_CONFIG_PROP_ENUM (object_class, PROP_LAYER_PREVIEW_SIZE,
-  GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_COLOR_MANAGEMENT,
+                         "layer-preview-size",
-                                   "color-management", COLOR_MANAGEMENT_BLURB,
+                         "Layer preview size",
-                                   GIMP_TYPE_COLOR_CONFIG,
+                         LAYER_PREVIEW_SIZE_BLURB,
-                                   GIMP_PARAM_STATIC_STRINGS |
+                         GIMP_TYPE_VIEW_SIZE,
-                                   GIMP_CONFIG_PARAM_AGGREGATE);
+                         GIMP_VIEW_SIZE_MEDIUM,
-  GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_COLOR_PROFILE_POLICY,
+                         GIMP_PARAM_STATIC_STRINGS);
-                                 "color-profile-policy",
+
-                                 COLOR_PROFILE_POLICY_BLURB,
+  GIMP_CONFIG_PROP_ENUM (object_class, PROP_THUMBNAIL_SIZE,
-                                 GIMP_TYPE_COLOR_PROFILE_POLICY,
+                         "thumbnail-size",
-                                 GIMP_COLOR_PROFILE_POLICY_ASK,
+                         "Thumbnail size",
-                                 GIMP_PARAM_STATIC_STRINGS);
+                         THUMBNAIL_SIZE_BLURB,
-  GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_SAVE_DOCUMENT_HISTORY,
+                         GIMP_TYPE_THUMBNAIL_SIZE,
-                                    "save-document-history",
+                         GIMP_THUMBNAIL_SIZE_NORMAL,
-                                    SAVE_DOCUMENT_HISTORY_BLURB,
+                         GIMP_PARAM_STATIC_STRINGS);
-                                    TRUE,
+
-                                    GIMP_PARAM_STATIC_STRINGS);
+  GIMP_CONFIG_PROP_MEMSIZE (object_class, PROP_THUMBNAIL_FILESIZE_LIMIT,
-  GIMP_CONFIG_INSTALL_PROP_RGB (object_class, PROP_QUICK_MASK_COLOR,
+                            "thumbnail-filesize-limit",
-                                "quick-mask-color", QUICK_MASK_COLOR_BLURB,
+                            "Thumbnail file size limie",
-                                TRUE, &red,
+                            THUMBNAIL_FILESIZE_LIMIT_BLURB,
-                                GIMP_PARAM_STATIC_STRINGS);
+                            0, GIMP_MAX_MEMSIZE, 1 << 22,
+                            GIMP_PARAM_STATIC_STRINGS);
+
+  GIMP_CONFIG_PROP_OBJECT (object_class, PROP_COLOR_MANAGEMENT,
+                           "color-management",
+                           "Color management",
+                           COLOR_MANAGEMENT_BLURB,
+                           GIMP_TYPE_COLOR_CONFIG,
+                           GIMP_PARAM_STATIC_STRINGS |
+                           GIMP_CONFIG_PARAM_AGGREGATE);
+
+  GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_SAVE_DOCUMENT_HISTORY,
+                            "save-document-history",
+                            "Save document history",
+                            SAVE_DOCUMENT_HISTORY_BLURB,
+                            TRUE,
+                            GIMP_PARAM_STATIC_STRINGS);
+
+  GIMP_CONFIG_PROP_RGB (object_class, PROP_QUICK_MASK_COLOR,
+                        "quick-mask-color",
+                        "Quick mask color",
+                        QUICK_MASK_COLOR_BLURB,
+                        TRUE, &red,
+                        GIMP_PARAM_STATIC_STRINGS);
 
   /*  only for backward compatibility:  */
-  GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_INSTALL_COLORMAP,
+  GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_INSTALL_COLORMAP,
-                                    "install-colormap", NULL,
+                            "install-colormap",
-                                    FALSE,
+                            NULL, NULL,
-                                    GIMP_PARAM_STATIC_STRINGS |
+                            FALSE,
-                                    GIMP_CONFIG_PARAM_IGNORE);
+                            GIMP_PARAM_STATIC_STRINGS |
-  GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_MIN_COLORS,
+                            GIMP_CONFIG_PARAM_IGNORE);
-                                "min-colors", NULL,
+
-                                27, 256, 144,
+  GIMP_CONFIG_PROP_INT (object_class, PROP_MIN_COLORS,
-                                GIMP_PARAM_STATIC_STRINGS |
+                        "min-colors",
-                                GIMP_CONFIG_PARAM_IGNORE);
+                        NULL, NULL,
+                        27, 256, 144,
+                        GIMP_PARAM_STATIC_STRINGS |
+                        GIMP_CONFIG_PARAM_IGNORE);
 }
 
 static void
@@ -641,6 +755,14 @@ gimp_core_config_set_property (GObject      *object,
       g_free (core_config->dynamics_path_writable);
       core_config->dynamics_path_writable = g_value_dup_string (value);
       break;
+    case PROP_MYPAINT_BRUSH_PATH:
+      g_free (core_config->mypaint_brush_path);
+      core_config->mypaint_brush_path = g_value_dup_string (value);
+      break;
+    case PROP_MYPAINT_BRUSH_PATH_WRITABLE:
+      g_free (core_config->mypaint_brush_path_writable);
+      core_config->mypaint_brush_path_writable = g_value_dup_string (value);
+      break;
     case PROP_PATTERN_PATH:
       g_free (core_config->pattern_path);
       core_config->pattern_path = g_value_dup_string (value);
@@ -681,14 +803,6 @@ gimp_core_config_set_property (GObject      *object,
       g_free (core_config->font_path_writable);
       core_config->font_path_writable = g_value_dup_string (value);
       break;
-    case PROP_MYPAINT_BRUSH_PATH:
-      g_free (core_config->mypaint_brush_path);
-      core_config->mypaint_brush_path = g_value_dup_string (value);
-      break;
-    case PROP_MYPAINT_BRUSH_PATH_WRITABLE:
-      g_free (core_config->mypaint_brush_path_writable);
-      core_config->mypaint_brush_path_writable = g_value_dup_string (value);
-      break;
     case PROP_DEFAULT_BRUSH:
       g_free (core_config->default_brush);
       core_config->default_brush = g_value_dup_string (value);
@@ -697,6 +811,10 @@ gimp_core_config_set_property (GObject      *object,
       g_free (core_config->default_dynamics);
       core_config->default_dynamics = g_value_dup_string (value);
       break;
+    case PROP_DEFAULT_MYPAINT_BRUSH:
+      g_free (core_config->default_mypaint_brush);
+      core_config->default_mypaint_brush = g_value_dup_string (value);
+      break;
     case PROP_DEFAULT_PATTERN:
       g_free (core_config->default_pattern);
       core_config->default_pattern = g_value_dup_string (value);
@@ -717,10 +835,6 @@ gimp_core_config_set_property (GObject      *object,
       g_free (core_config->default_font);
       core_config->default_font = g_value_dup_string (value);
       break;
-    case PROP_DEFAULT_MYPAINT_BRUSH:
-      g_free (core_config->default_mypaint_brush);
-      core_config->default_mypaint_brush = g_value_dup_string (value);
-      break;
     case PROP_GLOBAL_BRUSH:
       core_config->global_brush = g_value_get_boolean (value);
       break;
@@ -749,8 +863,8 @@ gimp_core_config_set_property (GObject      *object,
         gimp_config_sync (g_value_get_object (value),
                           G_OBJECT (core_config->default_grid), 0);
       break;
-    case PROP_PLUG_IN_HISTORY_SIZE:
+    case PROP_FILTER_HISTORY_SIZE:
-      core_config->plug_in_history_size = g_value_get_int (value);
+      core_config->filter_history_size = g_value_get_int (value);
       break;
     case PROP_UNDO_LEVELS:
       core_config->levels_of_undo = g_value_get_int (value);
@@ -782,9 +896,6 @@ gimp_core_config_set_property (GObject      *object,
         gimp_config_sync (g_value_get_object (value),
                           G_OBJECT (core_config->color_management), 0);
       break;
-    case PROP_COLOR_PROFILE_POLICY:
-      core_config->color_profile_policy = g_value_get_enum (value);
-      break;
     case PROP_SAVE_DOCUMENT_HISTORY:
       core_config->save_document_history = g_value_get_boolean (value);
       break;
@@ -846,6 +957,12 @@ gimp_core_config_get_property (GObject    *object,
     case PROP_DYNAMICS_PATH_WRITABLE:
       g_value_set_string (value, core_config->dynamics_path_writable);
       break;
+    case PROP_MYPAINT_BRUSH_PATH:
+      g_value_set_string (value, core_config->mypaint_brush_path);
+      break;
+    case PROP_MYPAINT_BRUSH_PATH_WRITABLE:
+      g_value_set_string (value, core_config->mypaint_brush_path_writable);
+      break;
     case PROP_PATTERN_PATH:
       g_value_set_string (value, core_config->pattern_path);
       break;
@@ -876,18 +993,15 @@ gimp_core_config_get_property (GObject    *object,
     case PROP_FONT_PATH_WRITABLE:
       g_value_set_string (value, core_config->font_path_writable);
       break;
-    case PROP_MYPAINT_BRUSH_PATH:
-      g_value_set_string (value, core_config->mypaint_brush_path);
-      break;
-    case PROP_MYPAINT_BRUSH_PATH_WRITABLE:
-      g_value_set_string (value, core_config->mypaint_brush_path_writable);
-      break;
     case PROP_DEFAULT_BRUSH:
       g_value_set_string (value, core_config->default_brush);
       break;
     case PROP_DEFAULT_DYNAMICS:
       g_value_set_string (value, core_config->default_dynamics);
       break;
+    case PROP_DEFAULT_MYPAINT_BRUSH:
+      g_value_set_string (value, core_config->default_mypaint_brush);
+      break;
     case PROP_DEFAULT_PATTERN:
       g_value_set_string (value, core_config->default_pattern);
       break;
@@ -903,9 +1017,6 @@ gimp_core_config_get_property (GObject    *object,
     case PROP_DEFAULT_FONT:
       g_value_set_string (value, core_config->default_font);
       break;
-    case PROP_DEFAULT_MYPAINT_BRUSH:
-      g_value_set_string (value, core_config->default_mypaint_brush);
-      break;
     case PROP_GLOBAL_BRUSH:
       g_value_set_boolean (value, core_config->global_brush);
       break;
@@ -930,8 +1041,8 @@ gimp_core_config_get_property (GObject    *object,
     case PROP_DEFAULT_GRID:
       g_value_set_object (value, core_config->default_grid);
       break;
-    case PROP_PLUG_IN_HISTORY_SIZE:
+    case PROP_FILTER_HISTORY_SIZE:
-      g_value_set_int (value, core_config->plug_in_history_size);
+      g_value_set_int (value, core_config->filter_history_size);
       break;
     case PROP_UNDO_LEVELS:
       g_value_set_int (value, core_config->levels_of_undo);
@@ -960,9 +1071,6 @@ gimp_core_config_get_property (GObject    *object,
     case PROP_COLOR_MANAGEMENT:
       g_value_set_object (value, core_config->color_management);
       break;
-    case PROP_COLOR_PROFILE_POLICY:
-      g_value_set_enum (value, core_config->color_profile_policy);
-      break;
     case PROP_SAVE_DOCUMENT_HISTORY:
       g_value_set_boolean (value, core_config->save_document_history);
       break;