etc: make the new bash-completion file work for all variants of our executables.

In particular make it also work with the `gimp-console` and with all
symlink names.

Also rename the bash completion file using the full application version
so that it will be possible to install several such completion files
side by side.

.clang-format

@@ -15,9 +15,13 @@ AlignConsecutiveBitFields: AcrossComments
 AlignConsecutiveMacros: AcrossComments
 AlignEscapedNewlines: Left
 
+AllowAllArgumentsOnNextLine: false
 AllowAllParametersOfDeclarationOnNextLine: false
 AlwaysBreakAfterReturnType: AllDefinitions
-BinPackParameters: false
+BinPackArguments: true
+# Uncomment when our CI uses LLVM 20.
+# See: https://github.com/llvm/llvm-project/issues/117830
+# BinPackParameters: AlwaysOnePerLine
 BreakBeforeBinaryOperators: None
 BreakBeforeBraces: GNU
 BreakBeforeTernaryOperators: false

.gitignore

@@ -1,2 +0,0 @@
-# Meson
-/compile_commands.json

.gitlab-ci.yml

@@ -1,11 +1,32 @@
-# Our pipelines are auto cancelable when explicity set in 'rules'.
-# GitLab is quite sensitive about rules 'if' order so be careful.
+spec:
+  inputs:
+    distribution_pipeline:
+      description: 'Pipelines that creates installable GIMP'
+      options:
+        - GIMP_CI_APPIMAGE #trigger the appimage making.
+        - GIMP_CI_FLATPAK #trigger the flatpak build and publishing (base but slow)
+        - GIMP_CI_WIN_INSTALLER #trigger all native MSYS2 builds then creates Inno Windows installer (base but slow)
+        - GIMP_CI_MS_STORE #trigger arm64 and x64 native MSYS2 builds then creates a .msixbundle (base but slow)
+        - none
+      default: 'none'
+    test_pipeline:
+      description: 'Pipelines used only for testing'
+      options:
+        - GIMP_CI_MESON_GCC #trigger the Debian GCC build (rare usefulness)
+        - GIMP_CI_RASTER_ICONS #trigger the Debian Clang build without vector icons (rare usefulness)
+        - GIMP_CI_CPPCHECK #trigger cppcheck (static code analysis)
+        - none
+      default: 'none'
+---
+
 workflow:
   auto_cancel:
     on_new_commit: interruptible
 
 
-# There are five "TYPES" of pipelines on our CI:
+##################################################
+# There are five "TYPES" of pipelines on our CI: #
+##################################################
 
 ## 1. On MERGE REQUESTS, the following are triggered:
 ## - Abbreviated Linux Clang build (base & fast)
@@ -16,8 +37,9 @@ workflow:
   interruptible: true
   variables: {}
 
-## 2. LABELED MERGE REQUESTS (search for 'CI_MERGE_REQUEST_LABELS').
-  #'interruptible: true' needs to be hardcoded on job
+## 2. LABELED MERGE REQUESTS (search for $CI_MERGE_REQUEST_LABELS =~ /.*Package).
+  #'interruptible: true' needs to be hardcoded on job rules
+  # GitLab is quite sensitive about rules 'if' order so be careful
 
 ## 3. On COMMITS except tags.
 ## - Linux Clang build (base & fast)
@@ -41,22 +63,9 @@ workflow:
 
 .default:
   ## 5. On CUSTOM builds though web GUI, API or schedules.
-  ## Scheduled CI ($CI_PIPELINE_SOURCE == "schedule") will run regularly:
-  ## - GIMP_CI_MESON_GCC: trigger the Debian GCC build (rare usefulness).
-  ## - GIMP_CI_RASTER_ICONS: trigger the Debian Clang build without vector icons (rare usefulness).
-  ## - GIMP_CI_CPPCHECK: trigger cppcheck (static code analysis).
-  ## - GIMP_CI_APPIMAGE: trigger the appimage making (experimental).
-  ## - GIMP_CI_FLATPAK: trigger the flatpak build and publishing (base but slow).
-  ## - GIMP_CI_WIN_INSTALLER: trigger all native MSYS2 builds then creates Inno Windows installer (base but slow).
-  ## - GIMP_CI_MS_STORE: trigger arm64 and x64 native MSYS2 builds then creates a .msixbundle (base but slow).
-  ## In addition to the variables above, to force step-specific pipelines
-  ## without waiting for commits and/or schedules, these you should set on GUI:
-  ## - GIMP_CI_MESON_CLANG: trigger the Debian Clang build.
-  ## - GIMP_CI_CROSSROAD_WIN64: trigger the crossroad build for Win 64-bit.
-  ## - GIMP_CI_MSYS2_WIN_AARCH64: trigger the native MSYS2 build for Win Aarch64.
-  ## - GIMP_CI_MSYS2_WIN64: trigger the native MSYS2 build for Win 64-bit.
-  ## - GIMP_CI_MSYS2_WIN32: trigger the native MSYS2 build for Win 32-bit.
-  ## - GIMP_CI_SOURCES: trigger the Debian Clang build and the source tarball job.
+  ## Scheduled CI ($CI_PIPELINE_SOURCE == "schedule") will run regularly all
+  ## the 'distribution_pipeline' and 'test_pipeline' above. To run them without
+  ## waiting for schedules: https://gitlab.gnome.org/GNOME/gimp/-/pipelines/new
   interruptible: false
 
 
@@ -66,45 +75,36 @@ workflow:
     when:
       - 'runner_system_failure'
       - 'scheduler_failure'
+  needs: []
   # Default Docker image (unless otherwise defined)
   image: debian:${DEB_VERSION}
-  # Caching support
   variables:
-    CCACHE_BASEDIR: "$CI_PROJECT_DIR"
-    CCACHE_DIR: "$CI_PROJECT_DIR/_ccache"
-  cache:
-    key: ${CI_JOB_NAME_SLUG}${VARIANT}
-    paths:
-      - _ccache/
+    DEB_VERSION: "bookworm"
+    # Common cloning procedure
+    GIT_DEPTH: "1"
+    GIT_SUBMODULE_STRATEGY: none
+    # Enable colorful output when supported (e.g. ninja, cppcheck)
+    CLICOLOR_FORCE: "1"
   # Common artifacts behavior
   artifacts:
     name: "${CI_JOB_NAME_SLUG}${VARIANT}-${CI_COMMIT_REF_SLUG}-${CI_COMMIT_SHORT_SHA}"
     when: always
 
-variables:
-  DEB_VERSION: "bookworm"
-  # Common cloning procedure
-  GIT_DEPTH: "1"
-  GIT_SUBMODULE_STRATEGY: none
-  # Enable colorful output when supported (e.g. ninja, cppcheck)
-  CLICOLOR_FORCE: "1"
-
 
 stages:
-  - prepare
   - dependencies
   - gimp
   - analysis
   - distribution
 
-## prepare build-oriented Docker images ##
-
+## AppImage CI (Debian) ##
 .debian:
   extends: .default
   rules:
-    - if: '$CI_MERGE_REQUEST_LABELS =~ /.*5. AppImage package.*/'
+    - if: '$CI_MERGE_REQUEST_LABELS =~ /.*Package:AppImage.*/'
       interruptible: true
-    - if: '$GIMP_CI_APPIMAGE != null'
+    - if: '$GIMP_CI_APPIMAGE != null || "$[[ inputs.distribution_pipeline ]]" =~ /.*GIMP_CI_APPIMAGE.*/'
+    - <<: *CI_RELEASE
   parallel:
     matrix:
       - RUNNER: [aarch64, x86_64_v2]
@@ -118,62 +118,43 @@ stages:
     CXX_LD: lld
   before_script:
     - export GIMP_PREFIX="${CI_PROJECT_DIR}/_install-${RUNNER}"
-    - echo -e "\e[0Ksection_start:`date +%s`:environ[collapsed=true]\r\e[0KPreparing build environment"
-    - export PATH="$GIMP_PREFIX/bin:$PATH"
-    - gcc -print-multi-os-directory 2>/dev/null | grep ./ && export LIB_DIR=$(gcc -print-multi-os-directory | sed 's/\.\.\///g') || export LIB_DIR="lib"
-    - gcc -print-multiarch 2>/dev/null | grep . && export LIB_SUBDIR=$(echo $(gcc -print-multiarch)'/')
-    - export PKG_CONFIG_PATH="${GIMP_PREFIX}/${LIB_DIR}/${LIB_SUBDIR}pkgconfig${PKG_CONFIG_PATH:+:$PKG_CONFIG_PATH}"
-    - export LD_LIBRARY_PATH="${GIMP_PREFIX}/${LIB_DIR}/${LIB_SUBDIR}${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
-    - export XDG_DATA_DIRS="${GIMP_PREFIX}/share:/usr/share${XDG_DATA_DIRS:+:$XDG_DATA_DIRS}"
-    - export GI_TYPELIB_PATH="${GIMP_PREFIX}/${LIB_DIR}/${LIB_SUBDIR}girepository-1.0${GI_TYPELIB_PATH:+:$GI_TYPELIB_PATH}"
-    - echo -e "\e[0Ksection_end:`date +%s`:environ\r\e[0K"
+  timeout: 20m
 
-.debian-x64:
-  extends: .debian
-  rules:
-    - <<: *CI_MERGE
-    - <<: *CI_COMMIT
-    - if: '$GIMP_CI_MESON_CLANG != null'
-      variables: {}
-    - if: '$GIMP_CI_MESON_GCC != null'
-      variables:
-        CC: "ccache cc"
-        CXX: "ccache c++"
-        CC_LD: bfd
-        CXX_LD: bfd
-        VARIANT: "-gcc"
-    - if: '$GIMP_CI_RASTER_ICONS != null'
-      variables:
-        MESON_OPTIONS: "-Dvector-icons=false"
-        VARIANT: "-raster"
-    - if: '$GIMP_CI_CROSSROAD_WIN64 != null'
-    - if: '$GIMP_CI_SOURCES != null'
-    - <<: *CI_RELEASE
-  parallel:
-    matrix:
-      - RUNNER: x86_64_v2
+.debian_environ: &ENVIRON
+- echo -e "\e[0Ksection_start:`date +%s`:environ[collapsed=true]\r\e[0KPreparing build environment"
+- gcc -print-multi-os-directory 2>/dev/null | grep ./ && export LIB_DIR=$(gcc -print-multi-os-directory | sed 's/\.\.\///g') || export LIB_DIR="lib"
+- gcc -print-multiarch 2>/dev/null | grep . && export LIB_SUBDIR=$(echo $(gcc -print-multiarch)'/')
+## Build-time vars
+- export PKG_CONFIG_PATH="${GIMP_PREFIX}/${LIB_DIR}/${LIB_SUBDIR}pkgconfig${PKG_CONFIG_PATH:+:$PKG_CONFIG_PATH}"
+- export XDG_DATA_DIRS="${GIMP_PREFIX}/share:/usr/share${XDG_DATA_DIRS:+:$XDG_DATA_DIRS}"
+## Runtime vars
+- export PATH="${GIMP_PREFIX}/bin:$PATH"
+- export LD_LIBRARY_PATH="${GIMP_PREFIX}/${LIB_DIR}/${LIB_SUBDIR}${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
+- export GI_TYPELIB_PATH="${GIMP_PREFIX}/${LIB_DIR}/${LIB_SUBDIR}girepository-1.0${GI_TYPELIB_PATH:+:$GI_TYPELIB_PATH}"
+- echo -e "\e[0Ksection_end:`date +%s`:environ\r\e[0K"
 
-image-debian:
+deps-debian:
   extends: .debian
-  stage: prepare
+  stage: dependencies
   image:
     name: gcr.io/kaniko-project/executor:debug
     entrypoint: [""]
   variables:
     GIT_STRATEGY: none
     UMFPACK: libumfpack5
-  cache: []
-  before_script: []
+    PKGCONF_RELOCATABLE_OPTION: '-Dpkgconfig.relocatable=true'
   script:
     - export container=docker
     - mkdir -p /kaniko/.docker
     - echo "{\"auths\":{\"$CI_REGISTRY\":{\"username\":\"$CI_REGISTRY_USER\",\"password\":\"$CI_REGISTRY_PASSWORD\"}}}" > /kaniko/.docker/config.json
+    # Install deps
     - echo "FROM debian:${DEB_VERSION}" > Dockerfile
-    - echo "RUN apt-get update" >> Dockerfile
-    # 'ca-certificates' is NOT a gimp dep, it is installed only to our Docker image work
-    - echo "RUN apt-get install -y --no-install-recommends ca-certificates" >> Dockerfile
-    # Build-time only dependencies
-    - echo "RUN apt-get install -y --no-install-recommends \\" >> Dockerfile
+    - echo "RUN echo -e \"\e[0Ksection_start:0000000001:deps_install[collapsed=true]\r\e[0KInstalling dependencies provided by Debian $DEB_VERSION\"" >> Dockerfile
+    - echo "RUN apt-get update -qq" >> Dockerfile
+    ## 'ca-certificates' is NOT a gimp dep, it is installed only to our Docker image work
+    - echo "RUN apt-get install -qq -y --no-install-recommends ca-certificates" >> Dockerfile
+    ## Build-time only dependencies
+    - echo "RUN apt-get install -qq -y --no-install-recommends \\" >> Dockerfile
     - echo "appstream
             ccache
             clang
@@ -182,16 +163,14 @@ image-debian:
             git
             gobject-introspection
             libgtk-3-bin
-            libtool
             lld
             meson
             valac
             xauth
             xsltproc
-            xvfb
-            yelp-tools" >> Dockerfile
-    # Dependencies
-    - echo "RUN apt-get install -y --no-install-recommends \\" >> Dockerfile
+            xvfb" >> Dockerfile
+    ## Runtime dependencies
+    - echo "RUN apt-get install -qq -y --no-install-recommends \\" >> Dockerfile
     - echo "at-spi2-core
             ffmpeg
             gettext
@@ -238,65 +217,39 @@ image-debian:
             mypaint-brushes
             poppler-data
             python3
-            python3-gi" >> Dockerfile
-    - /kaniko/executor --context $CI_PROJECT_DIR --dockerfile $CI_PROJECT_DIR/Dockerfile --destination $CI_REGISTRY_IMAGE:build-debian-${DEB_VERSION}-${RUNNER} --cache=true --cache-ttl=120h
-
-image-debian-x64:
-  extends: .debian-x64
-  stage: !reference [image-debian, stage]
-  image: !reference [image-debian, image]
-  variables: !reference [image-debian, variables]
-  cache: !reference [image-debian, cache]
-  before_script:
-   - !reference [image-debian, before_script]
-  script:
-    - !reference [image-debian, script]
-
-## GNU/Linux 64-bit CIs (Debian) ##
-
-deps-debian:
-  extends: .debian
-  needs: ["image-debian"]
-  stage: dependencies
-  variables:
-    GIT_STRATEGY: none
-    CCACHE_MAXSIZE: 0.25G
-  script:
-    # Clone and build babl
-    - echo -e "\e[0Ksection_start:`date +%s`:babl_build[collapsed=true]\r\e[0KBuilding babl"
-    - if [ "$CI_COMMIT_TAG" != "" ]; then
-        repo=https://gitlab.gnome.org/GNOME/babl.git;
-        babl_tag=$(git ls-remote --tags --exit-code --refs "$repo" |
-                   grep -oi "BABL_[0-9]*_[0-9]*_[0-9]*"            |
-                   sort --version-sort | tail -1);
-        babl_branch="--branch=$babl_tag";
-      fi
-    - git clone $babl_branch --depth=${GIT_DEPTH} https://gitlab.gnome.org/GNOME/babl.git
-    - cd babl
-    - meson setup _build-${RUNNER} -Dprefix="${GIMP_PREFIX}"
-    - cd _build-${RUNNER}
-    - ninja
-    - ninja install
-    - ccache --show-stats
-    - cd ../..
-    - echo -e "\e[0Ksection_end:`date +%s`:babl_build\r\e[0K"
-    # Clone and build gegl
-    - echo -e "\e[0Ksection_start:`date +%s`:gegl_build[collapsed=true]\r\e[0KBuilding gegl"
-    - if [ "$CI_COMMIT_TAG" != "" ]; then
-        repo=https://gitlab.gnome.org/GNOME/gegl.git;
-        gegl_tag=$(git ls-remote --tags --exit-code --refs "$repo" |
-                   grep -oi "GEGL_[0-9]*_[0-9]*_[0-9]*"            |
-                   sort --version-sort | tail -1);
-        gegl_branch="--branch=$gegl_tag";
-      fi
-    - git clone $gegl_branch --depth=${GIT_DEPTH} https://gitlab.gnome.org/GNOME/gegl.git
-    - cd gegl
-    - meson setup _build-${RUNNER} -Dprefix="${GIMP_PREFIX}" -Dworkshop=true
-    - cd _build-${RUNNER}
-    - ninja
-    - ninja install
-    - ccache --show-stats
-    - echo -e "\e[0Ksection_end:`date +%s`:gegl_build\r\e[0K"
+            python3-gi
+            python3-gi-cairo" >> Dockerfile
+    - echo "RUN echo -e \"\e[0Ksection_end:0000000002:deps_install\r\e[0K\"" >> Dockerfile
+    # Prepare environ
+    - echo "FROM $CI_REGISTRY_IMAGE:build-debian-${DEB_VERSION}-${RUNNER}" > Dockerfile2;
+    - echo "RUN echo -e \"\e[0Ksection_start:`date +%s`:environ[collapsed=true]\r\e[0KPreparing build environment\"" >> Dockerfile2;
+    - export LIB_DIR="lib";
+    - export LIB_SUBDIR=$([ "$(uname -m)" = 'aarch64' ] && echo "aarch64-linux-gnu/" || echo "x86_64-linux-gnu/");
+    - echo "ENV PKG_CONFIG_PATH=\"${GIMP_PREFIX}/${LIB_DIR}/${LIB_SUBDIR}pkgconfig${PKG_CONFIG_PATH:+:$PKG_CONFIG_PATH}\"" >> Dockerfile2;
+    - echo "ENV XDG_DATA_DIRS=\"${GIMP_PREFIX}/share:/usr/share${XDG_DATA_DIRS:+:$XDG_DATA_DIRS}\"" >> Dockerfile2;
+    - echo "ENV CC=\"$CC\"" >> Dockerfile2;
+    - echo "ENV CXX=\"$CXX\"" >> Dockerfile2;
+    - echo "ENV CC_LD=\"$CC_LD\"" >> Dockerfile2;
+    - echo "ENV CXX_LD=\"$CXX_LD\"" >> Dockerfile2;
+    - echo "ENV CLICOLOR_FORCE=\"1\"" >> Dockerfile2;
+    - echo "RUN echo -e \"\e[0Ksection_end:`date +%s`:environ\r\e[0K\"" >> Dockerfile2;
+    # Build some dependencies
+    ## Build babl
+    - echo "RUN echo -e \"\e[0Ksection_start:`date +%s`:babl_build[collapsed=true]\r\e[0KBuilding babl\"" >> Dockerfile2;
+    - echo "RUN git clone --branch \"\$([ \"$CI_COMMIT_TAG\" ] && echo \"\$(git ls-remote --tags --exit-code --refs https://gitlab.gnome.org/GNOME/babl.git | grep -oi \"BABL_[0-9]*_[0-9]*_[0-9]*\" | sort --version-sort | tail -1)\" || echo \"master\")\" --depth=${GIT_DEPTH} https://gitlab.gnome.org/GNOME/babl.git" $CI_PROJECT_DIR/babl >> Dockerfile2;
+    - echo "RUN meson setup $CI_PROJECT_DIR/babl/_build-${RUNNER} $CI_PROJECT_DIR/babl -Dprefix=\"${GIMP_PREFIX}\" $PKGCONF_RELOCATABLE_OPTION" >> Dockerfile2;
+    - echo "RUN ninja -C $CI_PROJECT_DIR/babl/_build-${RUNNER}" >> Dockerfile2;
+    - echo "RUN ninja -C $CI_PROJECT_DIR/babl/_build-${RUNNER} install" >> Dockerfile2;
+    - echo "RUN echo -e \"\e[0Ksection_end:`date +%s`:babl_build\r\e[0K\"" >> Dockerfile2;
+    ## Build GEGL
+    - echo "RUN echo -e \"\e[0Ksection_start:`date +%s`:gegl_build[collapsed=true]\r\e[0KBuilding gegl\"" >> Dockerfile2;
+    - echo "RUN git clone --branch \"\$([ \"$CI_COMMIT_TAG\" ] && echo \"\$(git ls-remote --tags --exit-code --refs https://gitlab.gnome.org/GNOME/gegl.git | grep -oi \"GEGL_[0-9]*_[0-9]*_[0-9]*\" | sort --version-sort | tail -1)\" || echo \"master\")\" --depth=${GIT_DEPTH} https://gitlab.gnome.org/GNOME/gegl.git" $CI_PROJECT_DIR/gegl >> Dockerfile2;
+    - echo "RUN meson setup $CI_PROJECT_DIR/gegl/_build-${RUNNER} $CI_PROJECT_DIR/gegl -Dprefix=\"${GIMP_PREFIX}\" $PKGCONF_RELOCATABLE_OPTION $WORKSHOP_OPTION" >> Dockerfile2;
+    - echo "RUN ninja -C $CI_PROJECT_DIR/gegl/_build-${RUNNER}" >> Dockerfile2;
+    - echo "RUN ninja -C $CI_PROJECT_DIR/gegl/_build-${RUNNER} install" >> Dockerfile2;
+    - echo "RUN echo -e \"\e[0Ksection_end:`date +%s`:gegl_build\r\e[0K\"" >> Dockerfile2;
+    - /kaniko/executor --context $CI_PROJECT_DIR --dockerfile $CI_PROJECT_DIR/Dockerfile --destination $CI_REGISTRY_IMAGE:build-debian-${DEB_VERSION}-${RUNNER} --cache=true --cache-ttl=120h --image-fs-extract-retry 1 --verbosity=warn
+    - if [ -f 'Dockerfile2' ]; then /kaniko/executor --context $CI_PROJECT_DIR --dockerfile $CI_PROJECT_DIR/Dockerfile2 --destination build-debian-${DEB_VERSION}-${RUNNER}-temp --cache=false --no-push --verbosity=warn; fi
   artifacts:
     paths:
       - _install-${RUNNER}/
@@ -312,15 +265,17 @@ gimp-debian:
   stage: gimp
   variables:
     GIT_SUBMODULE_STRATEGY: recursive
-    CCACHE_MAXSIZE: 0.75G
   script:
+    - *ENVIRON
     # Build GIMP
     - echo -e "\e[0Ksection_start:`date +%s`:gimp_build[collapsed=true]\r\e[0KBuilding GIMP"
     - meson setup _build-${RUNNER} -Dprefix="${GIMP_PREFIX}"
+                                   -Dpkgconfig.relocatable=true
                                    -Drelocatable-bundle=yes
+                                   -Dcheck-update=yes
+                                   -Dbuild-id=org.gimp.GIMP_official.AppImage.$(uname -m)
     - cd _build-${RUNNER}
     - ninja
-    - ccache --show-stats
     - echo -e "\e[0Ksection_end:`date +%s`:gimp_build\r\e[0K"
     # Create bundle
     - echo -e "\e[0Ksection_start:`date +%s`:gimp_bundle[collapsed=true]\r\e[0KCreating bundle"
@@ -332,14 +287,44 @@ gimp-debian:
     paths:
       - AppDir*/
       - appimageignore*
+      - _build-${RUNNER}/meson-logs/meson-log.txt
       - _build-${RUNNER}/config.h
     expire_in: 2 days
 
+
+## GNU/Linux 64-bit CIs (Debian) ##
+.debian-x64:
+  extends: .debian
+  rules:
+    - <<: *CI_MERGE
+    - <<: *CI_COMMIT
+    - if: '$GIMP_CI_MESON_CLANG != null'
+      variables: {}
+    - if: '$GIMP_CI_MESON_GCC != null || "$[[ inputs.test_pipeline ]]" =~ /.*GIMP_CI_MESON_GCC.*/'
+      variables:
+        CC: "cc"
+        CXX: "c++"
+        CC_LD: bfd
+        CXX_LD: bfd
+        VARIANT: "-gcc"
+    - if: '$GIMP_CI_RASTER_ICONS != null || "$[[ inputs.test_pipeline ]]" =~ /.*GIMP_CI_RASTER_ICONS.*/'
+      variables:
+        MESON_OPTIONS: "-Dvector-icons=false"
+        VARIANT: "-raster"
+    - if: '$GIMP_CI_SOURCES != null'
+    - <<: *CI_RELEASE
+  parallel:
+    matrix:
+      - RUNNER: x86_64_v2
+  tags: []
+
 deps-debian-x64:
   extends: .debian-x64
-  needs: ["image-debian-x64"]
   stage: !reference [deps-debian, stage]
-  variables: !reference [deps-debian, variables]
+  image: !reference [deps-debian, image]
+  variables:
+    GIT_STRATEGY: none
+    WORKSHOP_OPTION: '-Dworkshop=true'
   script:
     - !reference [deps-debian, script]
   artifacts: !reference [deps-debian, artifacts]
@@ -350,15 +335,14 @@ gimp-debian-x64:
   stage: !reference [gimp-debian, stage]
   variables: !reference [gimp-debian, variables]
   script:
+    - *ENVIRON
     # Check building
     - echo -e "\e[0Ksection_start:`date +%s`:gimp_build[collapsed=true]\r\e[0KBuilding GIMP"
     - meson setup _build-${RUNNER} -Dprefix="${GIMP_PREFIX}"
-                                   -Dg-ir-doc=true
                                    -Dfile-plug-ins-test=true
                                    $MESON_OPTIONS
     - cd _build-${RUNNER}
     - ninja
-    - ccache --show-stats
     - echo -e "\e[0Ksection_end:`date +%s`:gimp_build\r\e[0K"
     # Check execution
     - echo -e "\e[0Ksection_start:`date +%s`:gimp_test[collapsed=true]\r\e[0KTesting GIMP execution"
@@ -385,38 +369,33 @@ gimp-debian-x64:
       - _build-${RUNNER}/meson-logs/meson-log.txt
       - _build-${RUNNER}/meson-dist/
       - _build-${RUNNER}/config.h
-      - _build-${RUNNER}/devel-docs/
     reports:
       junit: "_build-${RUNNER}/meson-logs/testlog.junit.xml"
     expire_in: 2 days
 
-## Flatpak CI ##
 
+## Flatpak CI ##
 .flatpak-x64:
   extends: .default
   rules:
-    - if: '$CI_MERGE_REQUEST_LABELS =~ /.*5. Flatpak package.*/'
+    - if: '$CI_MERGE_REQUEST_LABELS =~ /.*Package:Flatpak.*/'
       interruptible: true
-    - if: '$GIMP_CI_FLATPAK != null'
+    - if: '$GIMP_CI_FLATPAK != null || "$[[ inputs.distribution_pipeline ]]" =~ /.*GIMP_CI_FLATPAK.*/'
   tags:
     - flatpak
   image: 'quay.io/gnome_infrastructure/gnome-runtime-images:gnome-master'
   before_script:
     - export GIMP_PREFIX="${CI_PROJECT_DIR}/_install"
+  timeout: 40m
 
 deps-flatpak-x64:
   extends: .flatpak-x64
-  needs: []
   stage: dependencies
-  # FIXME: GitLab CI caching does NOT work with flatpak
-  # See: https://gitlab.gnome.org/Infrastructure/Infrastructure/-/issues/1502
-  cache: []
-    # key: ${CI_JOB_NAME}-pkg
-    # paths:
-        # .flatpak-builder/
-    # key: $CI_JOB_NAME
-    # paths:
-        # _ccache/
+  #https://gitlab.gnome.org/Infrastructure/Infrastructure/-/issues/1502
+  #cache:
+    #key: ${CI_JOB_NAME_SLUG}
+    #paths:
+      #- .flatpak-builder/
   script:
     - bash build/linux/flatpak/1_build-deps-flatpak.sh
   artifacts:
@@ -431,12 +410,6 @@ gimp-flatpak-x64:
   extends: .flatpak-x64
   needs: ["deps-flatpak-x64"]
   stage: gimp
-  # FIXME: GitLab CI caching does NOT work with flatpak
-  # See: https://gitlab.gnome.org/Infrastructure/Infrastructure/-/issues/1502
-  cache: []
-    # key: $CI_JOB_NAME
-    # paths:
-        # _ccache/
   variables:
     GIT_SUBMODULE_STRATEGY: recursive
   script:
@@ -447,80 +420,34 @@ gimp-flatpak-x64:
       - gimp-meson-log.tar
     expire_in: 2 days
 
-## WINDOWS 64-bit CI (cross-build crossroad) ##
-
-.win-cross:
-  extends: .debian-x64
-  rules:
-    - <<: *CI_MERGE
-    - <<: *CI_COMMIT
-    - if: '$GIMP_CI_CROSSROAD_WIN64 != null'
-  variables:
-    DEB_VERSION: testing
-    MSYSTEM_PREFIX: clang64
-  cache: []
-
-image-debian-x64-cross:
-  extends: .win-cross
-  stage: !reference [image-debian, stage]
-  image: !reference [image-debian, image]
-  variables:
-    GIT_STRATEGY: none
-    UMFPACK: libumfpack6
-  cache: !reference [image-debian, cache]
-  before_script:
-   - !reference [image-debian, before_script]
-  script:
-    - !reference [image-debian, script]
-
-deps-win-x64-cross:
-  extends: .win-cross
-  needs: ["image-debian-x64-cross"]
-  stage: dependencies
-  before_script: []
-  script:
-    - bash build/windows/1_build-deps-quasimsys2.sh
-  artifacts:
-    paths:
-      - quasi-msys2/
-      - _install-$MSYSTEM_PREFIX-cross/
-      - babl/_build-$MSYSTEM_PREFIX-cross/meson-logs/meson-log.txt
-      - gegl/_build-$MSYSTEM_PREFIX-cross/meson-logs/meson-log.txt
-    expire_in: 2 hours
-
-gimp-win-x64-cross:
-  extends: .win-cross
-  needs: ["deps-win-x64-cross", "gimp-debian-x64"]
-  stage: gimp
-  variables:
-    GIT_SUBMODULE_STRATEGY: recursive
-  script:
-    - bash build/windows/2_build-gimp-quasimsys2.sh
-  artifacts:
-    expose_as: 'Windows zip'
-    paths:
-      - gimp-clang64/
-      - _build-clang64-cross/meson-logs/meson-log.txt
-      - _build-clang64-cross/done-dll.list
-    expire_in: 2 days
 
 ## WINDOWS pipelines (native MSYS2) ##
 .win:
   extends: .default
   rules:
-    - if: ($CI_MERGE_REQUEST_LABELS =~ /.*5. Windows Installer.*/ && $CI_MERGE_REQUEST_LABELS =~ /.*5. Microsoft Store.*/) || ($GIMP_CI_WIN_INSTALLER != null && $GIMP_CI_MS_STORE != null)
+    - if: '$CI_MERGE_REQUEST_LABELS =~ /.*Package:Windows Installer.*/ && $CI_MERGE_REQUEST_LABELS =~ /.*Package:Microsoft Store.*/'
       interruptible: true
       variables:
         INSTALLER_OPTION: '-Dwindows-installer=true'
         STORE_OPTION: '-Dms-store=true'
-    - if: $CI_MERGE_REQUEST_LABELS =~ /.*5. Windows Installer.*/ || $GIMP_CI_WIN_INSTALLER != null
+    - if: '$CI_MERGE_REQUEST_LABELS =~ /.*Package:Windows Installer.*/'
       interruptible: true
       variables:
         INSTALLER_OPTION: '-Dwindows-installer=true'
-    - if: ($CI_MERGE_REQUEST_LABELS =~ /.*5. Microsoft Store.*/ || $GIMP_CI_MS_STORE != null) && $CI_JOB_NAME !~ /.*86.*/ && $CI_JOB_NAME !~ /.*installer.*/
+    - if: '$CI_MERGE_REQUEST_LABELS =~ /.*Package:Microsoft Store.*/ && $CI_JOB_NAME =~ /.*64.*/ && $CI_JOB_NAME !~ /.*installer.*/'
       interruptible: true
       variables:
         STORE_OPTION: '-Dms-store=true'
+    - if: '$GIMP_CI_WIN_INSTALLER != null && $GIMP_CI_MS_STORE != null'
+      variables:
+        INSTALLER_OPTION: '-Dwindows-installer=true'
+        STORE_OPTION: '-Dms-store=true'
+    - if: '$GIMP_CI_WIN_INSTALLER != null || "$[[ inputs.distribution_pipeline ]]" =~ /.*GIMP_CI_WIN_INSTALLER.*/'
+      variables:
+        INSTALLER_OPTION: '-Dwindows-installer=true'
+    - if: '$GIMP_CI_MS_STORE != null || "$[[ inputs.distribution_pipeline ]]" =~ /.*GIMP_CI_MS_STORE.*/ && $CI_JOB_NAME =~ /.*64.*/ && $CI_JOB_NAME !~ /.*installer.*/'
+      variables:
+        STORE_OPTION: '-Dms-store=true'
     - <<: *CI_RELEASE
       variables:
         INSTALLER_OPTION: '-Dwindows-installer=true'
@@ -533,26 +460,30 @@ gimp-win-x64-cross:
         MSYSTEM_PREFIX: clang64
   tags:
     - $RUNNER
+  variables:
+    MSYS_ROOT: 'C:/msys64'
+    CC: cc
+    CXX: c++
+    #meson.build forces non-relocatable .pc. See: https://github.com/mesonbuild/meson/issues/14346
+    PKGCONF_RELOCATABLE_OPTION: '-Dpkgconfig.relocatable=true'
   before_script:
-    # MSYS2 config
-    - $MSYS2_PREFIX = 'C:/msys64'
-    - $env:Path = "$MSYS2_PREFIX/$MSYSTEM_PREFIX/bin;$MSYS2_PREFIX/usr/bin;" + $env:Path
-    # Build-time vars
     # FIXME:'gimpenv' have buggy code about Windows paths. See: https://gitlab.gnome.org/GNOME/gimp/-/issues/12284
     - $GIMP_PREFIX = "$PWD\_install-$MSYSTEM_PREFIX".Replace('\', '/')
-    - Write-Output "$([char]27)[0Ksection_start:$(Get-Date -UFormat %s -Millisecond 0):win_environ[collapsed=true]$([char]13)$([char]27)[0KPreparing build environment"
-    - $env:Path = $env:Path + ";$GIMP_PREFIX/bin"
-    - $env:PKG_CONFIG_PATH = "$MSYS2_PREFIX/$MSYSTEM_PREFIX/lib/pkgconfig;$MSYS2_PREFIX/$MSYSTEM_PREFIX/share/pkgconfig;$GIMP_PREFIX/lib/pkgconfig"
-    - $env:XDG_DATA_DIRS = "$MSYS2_PREFIX/$MSYSTEM_PREFIX/share;$GIMP_PREFIX/share"
-    - $env:GI_TYPELIB_PATH = "$MSYS2_PREFIX/$MSYSTEM_PREFIX/lib/girepository-1.0;$GIMP_PREFIX/lib/girepository-1.0"
-    - Write-Output "$([char]27)[0Ksection_end:$(Get-Date -UFormat %s -Millisecond 0):win_environ$([char]13)$([char]27)[0K"
+  timeout: 40m
+
+.win_environ: &WIN_ENVIRON
+- Write-Output "$([char]27)[0Ksection_start:$(Get-Date -UFormat %s -Millisecond 0):win_environ[collapsed=true]$([char]13)$([char]27)[0KPreparing build environment"
+## Build-time vars
+- $env:PKG_CONFIG_PATH = "$GIMP_PREFIX/lib/pkgconfig;$MSYS_ROOT/$MSYSTEM_PREFIX/lib/pkgconfig;$MSYS_ROOT/$MSYSTEM_PREFIX/share/pkgconfig"
+- $env:XDG_DATA_DIRS = "$GIMP_PREFIX/share;$MSYS_ROOT/$MSYSTEM_PREFIX/share"
+## Runtime vars
+- $env:PATH = "$GIMP_PREFIX/bin;$MSYS_ROOT/$MSYSTEM_PREFIX/bin;" + $env:PATH
+- $env:GI_TYPELIB_PATH = "$GIMP_PREFIX/lib/girepository-1.0;$MSYS_ROOT/$MSYSTEM_PREFIX/lib/girepository-1.0"
+- Write-Output "$([char]27)[0Ksection_end:$(Get-Date -UFormat %s -Millisecond 0):win_environ$([char]13)$([char]27)[0K"
 
 deps-win:
   extends: .win
-  needs: []
   stage: dependencies
-  variables:
-    CCACHE_MAXSIZE: 0.25G
   script:
     - build/windows/1_build-deps-msys2.ps1
   artifacts:
@@ -568,7 +499,6 @@ gimp-win:
   stage: gimp
   variables:
     GIT_SUBMODULE_STRATEGY: recursive
-    CCACHE_MAXSIZE: 0.75G
   script:
     - build/windows/2_build-gimp-msys2.ps1
   artifacts:
@@ -582,6 +512,7 @@ gimp-win:
       - _build-$MSYSTEM_PREFIX/build/windows/store/
     expire_in: 2 days
 
+
 ## WINDOWS x86 legacy CI (native MSYS2) ##
 .win-x86:
   extends: .win
@@ -592,12 +523,14 @@ gimp-win:
     matrix:
       - RUNNER: win32-ps
         MSYSTEM_PREFIX: mingw32
+  variables:
+    MINGW_PACKAGE_PREFIX: mingw-w64-i686
+    CC: cc
+    CXX: c++
 
 deps-win-x86:
   extends: .win-x86
-  needs: []
   stage: !reference [deps-win, stage]
-  variables: !reference [deps-win, variables]
   script:
     - !reference [deps-win, script]
   artifacts: !reference [deps-win, artifacts]
@@ -606,11 +539,10 @@ gimp-win-x86:
   extends: .win-x86
   needs: ["deps-win-x86"]
   stage: !reference [gimp-win, stage]
-  variables: !reference [gimp-win, variables]
+  variables:
+    GIT_SUBMODULE_STRATEGY: recursive
   script:
     - !reference [gimp-win, script]
-    # We split 32-bit DWARF symbols here because LLVM-objcopy do NOT support them
-    - bash build/windows/installer/3_dist-gimp-inno_sym.sh gimp-$MSYSTEM_PREFIX
   artifacts: !reference [gimp-win, artifacts]
 
 
@@ -624,7 +556,7 @@ file-plug-in-tests:
     # Don't run on release since the plug-in doesn't get installed in releases
     - <<: *CI_MERGE
     - <<: *CI_COMMIT
-  needs: ["deps-debian-x64", "gimp-debian-x64"]
+  needs: ["gimp-debian-x64"]
   stage: analysis
   variables:
     GIT_STRATEGY: none
@@ -632,12 +564,13 @@ file-plug-in-tests:
     GIMP_TESTS_LOG_FILE: "$CI_PROJECT_DIR/_log/import-tests.log"
     REGRESSION_STRING: "Total number of regressions: 0"
   cache:
-    - key: $CI_JOB_NAME
-      paths:
-        - _data
+    key: $CI_JOB_NAME
+    paths:
+      - _data
   script:
     - API_VER=$(grep GIMP_PKGCONFIG_VERSION _build*/config.h | head -1 | sed 's/^.*"\([^"]*\)"$/\1/')
     - APP_VER=$(grep GIMP_APP_VERSION _build*/config.h | head -1 | sed 's/^.*"\([^"]*\)"$/\1/')
+    - *ENVIRON
     - pkg-config --variable=gimplibdir gimp-${API_VER} 2>/dev/null | grep . && PLUG_IN_DIR=$(echo $(pkg-config --variable=gimplibdir gimp-${API_VER})'/plug-ins/')
     - export PYTHONPATH="${PLUG_IN_DIR}test-file-plug-ins"
     - export GIMP_TESTS_CONFIG_FILE="${PLUG_IN_DIR}test-file-plug-ins/tests/batch-config.ini"
@@ -659,13 +592,22 @@ file-plug-in-tests:
       junit: "_log/import-tests.xml"
     expire_in: 2 days
 
+meson-health:
+  extends: .default
+  rules:
+    - <<: *CI_MERGE
+    - <<: *CI_COMMIT
+  stage: analysis
+  script:
+    - apt-get update
+    - apt-get install -y git
+    - bash .gitlab/run_meson_health_diff.sh
+
 clang-format:
   extends: .default
   rules:
     - <<: *CI_MERGE
-  needs: []
   stage: analysis
-  cache: []
   script:
     - apt-get update
     - apt-get install -y clang-format
@@ -682,15 +624,13 @@ clang-format:
 cppcheck:
   extends: .default
   rules:
-    - if: '$GIMP_CI_CPPCHECK != null'
-  needs: []
+    - if: '$GIMP_CI_CPPCHECK != null || "$[[ inputs.test_pipeline ]]" =~ /.*GIMP_CI_CPPCHECK.*/'
   stage: analysis
-  cache: []
   script:
     - apt-get update
     - apt-get install -y cppcheck
     - cppcheck -q -j8 --enable=all --force --output-file=cppcheck.xml --xml --xml-version=2
-        -i _build -i _build-cross -i babl -i gegl -i _install -i .local -i .cache -i _ccache -i gimp-x64 .
+        -i _build -i babl -i gegl -i _install -i .local -i .cache -i gimp-x64 .
     - mkdir report
     - cppcheck-htmlreport --source-dir=. --title=gimp --file=cppcheck.xml --report-dir=report
   artifacts:
@@ -709,7 +649,6 @@ sources-debian:
     - <<: *CI_RELEASE
   needs: ["gimp-debian-x64"]
   stage: distribution
-  cache: []
   variables:
     GIT_STRATEGY: none
   script:
@@ -732,7 +671,6 @@ dev-docs:
     - <<: *CI_RELEASE
   needs: ["deps-debian-x64", "gimp-debian-x64"]
   stage: distribution
-  cache: []
   variables:
     GIT_STRATEGY: none
   script:
@@ -765,7 +703,6 @@ dev-docs:
       DIR_NAME=gimp-api-docs-$GIMP_VER                                                       &&
       mkdir $DIR_NAME                                                                        &&
       mv "${GIMP_PREFIX}/share/doc/gimp-$APP_VER" $DIR_NAME/reference                        &&
-      mv _build*/devel-docs/g-ir-docs $DIR_NAME/                                             &&
       TAR_NAME="$DIR_NAME.tar.xz"                                                            &&
       tar --dereference -cJf ${TAR_NAME} $DIR_NAME                                           &&
       sha256sum $TAR_NAME > ${TAR_NAME}.SHA256SUMS                                           &&
@@ -789,9 +726,8 @@ dist-appimage-weekly:
     - !reference [.debian, rules]
   needs: ["gimp-debian"]
   stage: distribution
-  cache: []
   script:
-    - bash build/linux/appimage/3_dist-gimp-goappimage.sh _build-x86_64_v2
+    - bash build/linux/appimage/3_dist-gimp-goappimage.sh
   artifacts:
     expose_as: 'Linux appimage'
     paths:
@@ -804,18 +740,17 @@ dist-flatpak-weekly:
     - .default
     - .publish_nightly
   rules:
-    - if: '$CI_MERGE_REQUEST_LABELS =~ /.*5. Flatpak package.*/'
+    - if: '$CI_MERGE_REQUEST_LABELS =~ /.*Package:Flatpak.*/'
       interruptible: true
-    - if: '$GIMP_CI_FLATPAK != null'
+    - if: '$GIMP_CI_FLATPAK != null || "$[[ inputs.distribution_pipeline ]]" =~ /.*GIMP_CI_FLATPAK.*/'
   needs: ["gimp-flatpak-x64"]
   stage: distribution
-  cache: []
   script:
     - bash build/linux/flatpak/3_dist-gimp-flatpak.sh
   artifacts:
     expose_as: 'Linux flatpak'
     paths:
-      - org.gimp.GIMP.Nightly.flatpak
+      - build/linux/flatpak/_Output/
     expire_in: 8 days
 
 dist-installer-weekly:
@@ -826,7 +761,8 @@ dist-installer-weekly:
   stage: distribution
   tags:
     - windows-aarch64
-  cache: []
+  variables:
+    MSYS_ROOT: 'C:/msys64'
   script:
     - build/windows/installer/3_dist-gimp-inno.ps1
   artifacts:
@@ -839,15 +775,14 @@ dist-installer-weekly:
 dist-store-weekly:
   extends: .default
   rules:
-    - if: '$CI_MERGE_REQUEST_LABELS =~ /.*5. Microsoft Store.*/'
+    - if: '$CI_MERGE_REQUEST_LABELS =~ /.*Package:Microsoft Store.*/'
       interruptible: true
-    - if: '$GIMP_CI_MS_STORE != null'
+    - if: '$GIMP_CI_MS_STORE != null || "$[[ inputs.distribution_pipeline ]]" =~ /.*GIMP_CI_MS_STORE.*/'
     - <<: *CI_RELEASE
   needs: ["gimp-win"]
   stage: distribution
   tags:
     - win32-ps
-  cache: []
   script:
     - build\windows\store\3_dist-gimp-winsdk.ps1
   artifacts:

.gitlab/issue_templates/Default.md

@@ -6,11 +6,15 @@ It is important that you fill all the fields of the template.
 
 There are a few issues we get reports about quite frequently. If you want to check if what you have encountered is among these, please see: 
 https://gitlab.gnome.org/GNOME/gimp/-/issues/?sort=updated_desc&state=all&label_name%5B%5D=Duplication%20target&first_page_size=100
+
+**Code of Conduct**: "Be considerate and respectful" is our main rule.
+E.g. avoid negative emotional writing which only generates more upsetting
+interactions. Thanks!
 -->
 
 ### Environment/Versions
 
-- GIMP version:
+- GIMP version number:
 - Package: <!--[flatpak? Installer from gimp.org? If another installer, tell us where from] (write it after the > symbol)-->
 - Operating System: <!--[Windows? macOS? Linux? All? Add OS versions too] (write it after the > symbol) -->
 - (if Linux) Display system: <!--[X11? Wayland? Which compositor and version?] (write it after the > symbol) -->
@@ -22,7 +26,7 @@ either in the last stable version of GIMP or on updated development code
 ### Description of the bug
 
 <!--Please describe your issue with details.
-Add screenshot or other files if needed.(write it after the > symbol)-->
+Add full (not cropped) screenshots or other files if needed.(write it after the > symbol)-->
 
 ### Reproduction
 

.gitlab/issue_templates/feature.md

@@ -3,8 +3,11 @@
 ### Description of the feature
 
 <!-- Please describe your feature with details. Also:
-- If the feature is UI-related, add screenshots, mockups or videos;
-- If the feature is about some standard or API, link relevant resources;
+- If the feature is UI-related, please DO NOT REPORT HERE but on
+  gimp-ux: https://gitlab.gnome.org/Teams/GIMP/Design/gimp-ux/-/issues;
+- If the feature is about some image file format on GIMP, first check if it
+  is not already listed on https://developer.gimp.org/core/standards/images,
+  then you can make the request, ideally linking relevant resources (e.g. specs);
 - If you have a patch, see: https://developer.gimp.org/core/submit-patch/ -->
 
 ### Use cases

.gitlab/merge_request_templates/default.md

@@ -8,8 +8,5 @@
 - Check the following option when making your request:
   "*Allow commits from members who can merge to the target branch.*"
 
-- Enable the container registry for your repository by following this
-  documentation, but enabling the feature instead of disabling it
-  (unlike what the docs says, Container Registry is disabled by default
-  on our Gitlab instance):
-  https://docs.gitlab.com/ee/user/packages/container_registry/#disable-the-container-registry-for-a-project -->
+- No AI-generated contents allowed (neither code nor text, images…).
+  Only human created works please! -->

.gitlab/run_meson_health_diff.sh

@@ -0,0 +1,167 @@
+#!/bin/bash
+
+source .gitlab/search-common-ancestor.sh
+
+diff=$(git diff -U0 --no-color "${newest_common_ancestor_sha}" -- '*.build' '*.py' | grep -E '^\+[^+]' | sed 's/^+//')
+
+
+#List of commonly used utilities on Unix world
+#See the context: https://gitlab.gnome.org/GNOME/gimp/-/issues/11385
+coreutils_array=(
+  ".sh"
+  "'sh'"
+  "'bash'"
+  "'\['"
+  "'arch'"
+  "'awk'"
+  "'b2sum'"
+  "'base32'"
+  "'base64'"
+  "'basename'"
+  "'basenc'"
+  "'cat'"
+  "'chcon'"
+  "'chgrp'"
+  "'chmod'"
+  "'chown'"
+  "'chroot'"
+  "'cksum'"
+  "'cmp'"
+  "'comm'"
+  "'cp'"
+  "'csplit'"
+  "'cut'"
+  "'date'"
+  "'dd'"
+  "'df'"
+  "'diff'"
+  "'dir'"
+  "'dircolors'"
+  "'dirname'"
+  "'du'"
+  "'echo'"
+  "'env'"
+  "'expand'"
+  "'expr'"
+  "'factor'"
+  "'false'"
+  "'find'"
+  "'fmt'"
+  "'fold'"
+  "'gkill'"
+  "'grep'"
+  "'groups'"
+  "'head'"
+  "'hostid'"
+  "'hostname'"
+  "'id'"
+  "'install'"
+  "'join'"
+  "'link'"
+  "'ln'"
+  "'logname'"
+  "'ls'"
+  "'md5sum'"
+  "'mkdir'"
+  "'mkfifo'"
+  "'mknod'"
+  "'mktemp'"
+  "'mv'"
+  "'nice'"
+  "'nl'"
+  "'nohup'"
+  "'nproc'"
+  "'numfmt'"
+  "'od'"
+  "'paste'"
+  "'pathchk'"
+  "'pinky'"
+  "'pr'"
+  "'printenv'"
+  "'printf'"
+  "'ptx'"
+  "'pwd'"
+  "'readlink'"
+  "'realpath'"
+  "'rm'"
+  "'rmdir'"
+  "'runcon'"
+  "'sed'"
+  "'seq'"
+  "'sha1sum'"
+  "'sha224sum'"
+  "'sha256sum'"
+  "'sha384sum'"
+  "'sha512sum'"
+  "'shred'"
+  "'shuf'"
+  "'sleep'"
+  "'sort'"
+  "'split'"
+  "'stat'"
+  "'stdbuf'"
+  "'stty'"
+  "'sum'"
+  "'sync'"
+  "'tac'"
+  "'tail'"
+  "'tee'"
+  "'test'"
+  "'timeout'"
+  "'touch'"
+  "'tr'"
+  "'true'"
+  "'truncate'"
+  "'tsort'"
+  "'tty'"
+  "'uname'"
+  "'unexpand'"
+  "'uniq'"
+  "'unlink'"
+  "'users'"
+  "'vdir'"
+  "'wc'"
+  "'who'"
+  "'whoami'"
+  "'yes'"
+)
+
+for coreutil in "${coreutils_array[@]}"; do
+  if echo "$diff" | grep -q "$coreutil"; then
+    found_coreutils+=" $coreutil"
+  fi
+done
+
+if [ "$found_coreutils" ]; then
+  echo -e '\033[31m(ERROR)\033[0m: Seems that you are trying to add an Unix-specific dependency to be called by Meson.'
+  echo "         Please, port to Python (which is crossplatform), your use of:${found_coreutils}."
+fi
+
+
+#Limited list of commonly used utilities on Windows world
+ntutils_array=(
+  ".bat"
+  ".cmd"
+  ".ps1"
+  "'cmd'"
+  "'powershell'"
+)
+
+for ntutil in "${ntutils_array[@]}"; do
+  if echo "$diff" | grep -q "$ntutil"; then
+    found_ntutils+=" $ntutil"
+  fi
+done
+
+if [ "$found_ntutils" ]; then
+  echo -e '\033[31m(ERROR)\033[0m: Seems that you are trying to add a NT-specific dependency to be called by Meson.'
+  echo "         Please, port to Python (which is crossplatform), your use of:${found_ntutils}."
+fi
+
+
+if [ "$found_coreutils" ] || [ "$found_ntutils" ]; then
+  exit 1
+fi
+
+echo 'Meson .build files are alright regarding crossplatform.'
+exit 0

.gitlab/search-common-ancestor.sh

@@ -24,13 +24,13 @@ git fetch --shallow-since="$(date --date="${ancestor_horizon} days ago" +%Y-%m-%
 # fall back to `${CI_DEFAULT_BRANCH}` or `${CI_COMMIT_BRANCH}` respectively
 # otherwise.
 
-# add mr-origin
-git remote add mr-origin ${CI_MERGE_REQUEST_SOURCE_PROJECT_URL}
+# add patch-origin
+git remote add patch-origin ${CI_MERGE_REQUEST_SOURCE_PROJECT_URL:-${CI_PROJECT_URL}}
 
 source_branch="${CI_MERGE_REQUEST_SOURCE_BRANCH_NAME:-${CI_COMMIT_BRANCH}}"
-git fetch --shallow-since="$(date --date="${ancestor_horizon} days ago" +%Y-%m-%d)" mr-origin "${source_branch}" &> ./fetch_origin.log
+git fetch --shallow-since="$(date --date="${ancestor_horizon} days ago" +%Y-%m-%d)" patch-origin "${source_branch}" &> ./fetch_origin.log
 
-newest_common_ancestor_sha=$(diff --old-line-format='' --new-line-format='' <(git rev-list --first-parent "upstream/${CI_MERGE_REQUEST_TARGET_BRANCH_NAME:-${CI_DEFAULT_BRANCH}}") <(git rev-list --first-parent "mr-origin/${source_branch}") | head -1)
+newest_common_ancestor_sha=$(diff --old-line-format='' --new-line-format='' <(git rev-list --first-parent "upstream/${CI_MERGE_REQUEST_TARGET_BRANCH_NAME:-${CI_DEFAULT_BRANCH}}") <(git rev-list --first-parent "patch-origin/${source_branch}") | head -1)
 if [ -z "${newest_common_ancestor_sha}" ]; then
     echo "Couldn’t find common ancestor with upstream main branch. This typically"
     echo "happens if you branched from main a long time ago. Please update"

AUTHORS

@@ -61,6 +61,7 @@ The following people have contributed code to GIMP:
  Jay Cox
  Kevin Cozens
  Jeremiah Darais
+ Shubham Daule
  Michael Deal
  Alexia Death
  Brian Degenhardt
@@ -81,6 +82,7 @@ The following people have contributed code to GIMP:
  Morton Eriksen
  Larry Ewing
  Dirk Farin
+ Idriss Fekir
  Pedro Alonso Ferrer
  Nick Fetchak
  Piotr Filiciak
@@ -170,6 +172,7 @@ The following people have contributed code to GIMP:
  Tobias Lenz
  Frederic Leroy
  Raph Levien
+ Bruno Lopes
  Wing Tung Leung
  Dave Lichterman
  Adrian Likins
@@ -352,7 +355,9 @@ The following people have contributed art to GIMP:
  Karl La Rocca
  Andreas Nilsson
  Ville Pätsi
+ Denis Rangelov
  Mike Schaeffer
+ Sevenix
  Carol Spears
  Klaus Staedtler
  Jakub Steiner

INSTALL.in

@@ -1,6 +1,6 @@
----------------------------------------
+--------------------------------------
 Installation instructions for GIMP @GIMP_APP_VERSION@
----------------------------------------
+--------------------------------------
 
 There are some basic steps to building and installing GIMP.
 
@@ -103,7 +103,7 @@ help in that regard:
      be installed. All these libraries are required dependencies.
 
   8. For metadata access GIMP requires the gexiv2 @GEXIV2_REQUIRED_VERSION@ or newer library.
-     It is hosted at: https://wiki.gnome.org/Projects/gexiv2
+     It is hosted at: https://gitlab.gnome.org/GNOME/gexiv2/
 
   9. libpng, libjpeg, libtiff, librsvg and lcms are hard dependencies
      that can not be disabled. poppler is also a hard dependency because
@@ -175,7 +175,7 @@ help in that regard:
      For HTTP support (and many other schemes), on Linux at least, you
      should install `gvfs`:
 
-        https://wiki.gnome.org/Projects/gvfs
+        https://gitlab.gnome.org/GNOME/gvfs/
 
      It is unclear whether `gvfs` can be built and installed on other
      platforms such as Windows and macOS.
@@ -200,10 +200,22 @@ help in that regard:
 
         https://github.com/strukturag/libheif
 
-     Make sure you build libheif with libde265 and libx265 support (for
-     respectively decoding and encoding of HEVC, i.e. HEIC files), and
-     libaom decoder and encoder (for AV1, i.e. AVIF files), otherwise
-     the plug-in is mostly useless.
+     GIMP supports several HEIF variants (different coding formats in
+     the HEIF container), so you should make sure you build libheif with
+     proper encoders and decoders for these:
+
+     * HEIC: e.g. libde265 and libx265 support (for
+             respectively decoding and encoding of HEVC).
+     * AVIF: e.g. libaom decoder and encoder (for AV1 encoding and
+             decoding), prefered over rav1e.
+     * HEJ2: OpenJPEG (for JPEG2000 inside HEIF).
+
+     If you don't compile libheif with the correct flags (see libheif
+     README which has a table of supported codecs), the plug-in is
+     mostly useless.
+     If HEIF support doesn't look like it works on relocatable
+     environments, the environment variable LIBHEIF_PLUGIN_PATH may be
+     what you are looking for.
 
  15. GObject Introspection requires the following dependencies to be
      built and installed with introspection as well: babl, cairo,
@@ -345,9 +357,10 @@ These are:
      a convenience for developers.
 
   -Dgimpdir=DIR.  This option changes the default directory GIMP uses to
-     search for its configuration files from ~/.config/GIMP/@GIMP_APP_VERSION@ (the
-     directory .config/GIMP/@GIMP_APP_VERSION@ in the user's home directory) to
-     ~/.config/DIR/@GIMP_APP_VERSION@.
+     search for its configuration files from $XDG_CONFIG_HOME/GIMP/@GIMP_APP_VERSION@/
+     (per XDG Base Directory Specification, $XDG_CONFIG_HOME defaults to
+     the directory .config/ in the user's home directory) to
+     $XDG_CONFIG_HOME/DIR/@GIMP_APP_VERSION@/.
      If DIR is an absolute path, the directory will be changed to DIR.
 
   -Dshmem-type=[none|sysv|posix|win32|auto].  This option allows you to
@@ -386,10 +399,6 @@ These are:
   -Dgi-docgen=enabled|disabled  This option controls whether the libgimp
      C API references will be created using gi-docgen.
 
-  -Dg-ir-doc=true  This option controls whether the libgimp API
-     references for some binding languages will be created using
-     g-ir-doc-tool and yelp-build.
-
   -Denable-multiproc=false This option allows you to disable support for
      multiple processors. It is enabled by default.
 

README

@@ -1,16 +1,14 @@
                    ------------------------------
                    GNU Image Manipulation Program
-                       3.0 Release Candidate
+                         3.0 Stable Branch
                    ------------------------------
 
-This is a release candidate for upcoming version 3.0.0 of GIMP.
-This is not considered stable yet, unless testing tell us it is.
-Therefore save your work early and often. If you want a stable
-version, please use GIMP 2.10 instead.
+This is a stable release in the GIMP 3.0 series.
 
-If you think you found a bug in this version, please report it! We are
-at the verge of releasing the next major version of GIMP, so any report
-helps.
+If you think you found a bug in this version, please make sure that it
+hasn't been reported earlier and that it is not just new stuff that is
+still being worked on and obviously not quite finished yet. If neither
+of these, please report it!
 
 If you want to hack on GIMP, please read the file devel-docs/README.md.
 For detailed installation instructions, see the file INSTALL.
@@ -24,7 +22,7 @@ GIMP's home page is at:
 	https://www.gimp.org/
 
 Please be sure to visit this site for information, documentation,
-tutorials, news, etc.  All things GIMP-ish are available from there.
+tutorials, news, etc. All things GIMP-ish are available from there.
 
 The latest version of GIMP can be found at:
 
@@ -81,11 +79,11 @@ also included in that page.
 The look of GIMP's interface can be customized like any other GTK+ app
 by editing files in `${XDG_CONFIG_HOME}/gtk-3.0/` (settings.ini and
 gtk.css in particular) or by using "themes" (ready-made customizations).
-Additionally, GIMP reads `${XDG_CONFIG_HOME}/GIMP/2.99/gimp.css` so you
+Additionally, GIMP reads `${XDG_CONFIG_HOME}/GIMP/3.0/gimp.css` so you
 can have settings that only apply to GIMP.
 
 You can also manually change the keybindings to any of your choice by
-editing: `${XDG_CONFIG_HOME}/GIMP/2.99/shortcutsrc`.
+editing: `${XDG_CONFIG_HOME}/GIMP/3.0/shortcutsrc`.
 
 
 Have fun,

app-tools/meson.build

@@ -32,11 +32,9 @@ if enable_default_bin
                     pointing_to: fs.name(gimp_debug_tool.full_path()),
                     install_dir: gimp_debug_tool_dir)
   else
-    meson.add_install_script('sh', '-c',
-                             'cp -f "@0@" "$MESON_INSTALL_DESTDIR_PREFIX/bin/@1@"'.format(gimp_debug_tool.full_path(),
-                                                                                          fs.name(gimp_debug_tool.name()).replace(exec_ver, '.exe')))
-    meson.add_install_script('sh', '-c',
-                             'cp -f "@0@" "$MESON_INSTALL_DESTDIR_PREFIX/bin/@1@"'.format(gimp_debug_tool.full_path(),
-                                                                                          fs.name(gimp_debug_tool.name()).replace(exec_ver, '-@0@.exe'.format(api_version_major))))
+    meson.add_install_script(python, '-c', 'from shutil import copy2; from pathlib import Path; from sys import argv; copy2(argv[1], str(Path(argv[2]) / "bin" / argv[3]))',
+                             gimp_debug_tool.full_path(), get_option('prefix'), fs.name(gimp_debug_tool.name()).replace(exec_ver, '.exe'))
+    meson.add_install_script(python, '-c', 'from shutil import copy2; from pathlib import Path; from sys import argv; copy2(argv[1], str(Path(argv[2]) / "bin" / argv[3].replace("@0@", argv[4])))',
+                             gimp_debug_tool.full_path(), get_option('prefix'), fs.name(gimp_debug_tool.name()).replace(exec_ver, '-@0@.exe'), api_version_major.to_string())
   endif
 endif

app/actions/context-commands.c

@@ -719,7 +719,7 @@ context_brush_radius_cmd_callback (GimpAction *action,
 
       radius = action_select_value (select_type,
                                     radius,
-                                    min_radius, 4000.0, min_radius,
+                                    min_radius, GIMP_BRUSH_GENERATED_MAX_RADIUS, min_radius,
                                     0.1, 1.0, 10.0, 0.05, FALSE);
       gimp_brush_generated_set_radius (generated, radius);
 

app/actions/dashboard-commands.c

@@ -111,6 +111,9 @@ dashboard_log_record_cmd_callback (GimpAction *action,
           GtkWidget              *label;
           GtkWidget              *spinbutton;
           GtkWidget              *toggle;
+          GDateTime              *datetime;
+          gchar                  *timestamp;
+          gchar                  *default_filename;
 
           dialog = gtk_file_chooser_dialog_new (
             "Record Performance Log", NULL, GTK_FILE_CHOOSER_ACTION_SAVE,
@@ -168,8 +171,19 @@ dashboard_log_record_cmd_callback (GimpAction *action,
                 GTK_FILE_CHOOSER (dialog), info->folder, NULL);
             }
 
+          datetime  = g_date_time_new_now_local ();
+
+          /* Since Windows doesn't allow colons in filenames,
+           * we use ISO 8601 basic format for the timestamp */
+          timestamp = g_date_time_format (datetime, "%Y%m%dT%H%M%SZ");
+          default_filename = g_strdup_printf ("gimp-performance-%s.log",
+                                              timestamp);
+          g_date_time_unref (datetime);
+          g_free (timestamp);
+
           gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog),
-                                             "gimp-performance.log");
+                                             default_filename);
+          g_free (default_filename);
 
           hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
           gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (dialog), hbox);

app/actions/edit-commands.c

@@ -403,7 +403,7 @@ edit_paste_cmd_callback (GimpAction *action,
                             GIMP_PASTE_TYPE_NEW_LAYER :
                             GIMP_PASTE_TYPE_NEW_LAYER_IN_PLACE;
 
-          edit_paste (display, converted_type, merged, FALSE);
+          edit_paste (display, converted_type, merged, TRUE);
         }
       g_list_free (drawables);
 

app/actions/file-actions.c

@@ -309,14 +309,34 @@ file_actions_update (GimpActionGroup *group,
 
   if (export)
     {
-      gchar *label = file_actions_create_label (_("Export to %s"), export);
+      GimpAction *action;
+      gchar      *label = file_actions_create_label (_("Export to %s"),
+                                                     export);
+
       gimp_action_group_set_action_label (group, "file-export", label);
+
+      action = gimp_action_group_get_action (group, "file-export");
+      g_object_set (action,
+                    "ellipsize",       PANGO_ELLIPSIZE_MIDDLE,
+                    "max-width-chars", 40,
+                    NULL);
+
       g_free (label);
     }
   else if (show_overwrite)
     {
-      gchar *label = file_actions_create_label (_("Over_write %s"), source);
+      GimpAction *action;
+      gchar      *label = file_actions_create_label (_("Over_write %s"),
+                                                     source);
+
       gimp_action_group_set_action_label (group, "file-overwrite", label);
+
+      action = gimp_action_group_get_action (group, "file-overwrite");
+      g_object_set (action,
+                    "ellipsize",       PANGO_ELLIPSIZE_MIDDLE,
+                    "max-width-chars", 40,
+                    NULL);
+
       g_free (label);
     }
   else
@@ -381,11 +401,13 @@ file_actions_last_opened_update (GimpContainer   *container,
               label   = g_strdup_printf (_("Open \"%s\""), escaped);
 
               g_object_set (action,
-                            "label",       label,
-                            "short-label", escaped,
-                            "tooltip",     name,
-                            "visible",     TRUE,
-                            "viewable",    imagefile,
+                            "label",           label,
+                            "short-label",     escaped,
+                            "tooltip",         name,
+                            "visible",         TRUE,
+                            "viewable",        imagefile,
+                            "ellipsize",       PANGO_ELLIPSIZE_MIDDLE,
+                            "max-width-chars", 40,
                             NULL);
 
               g_free (label);
@@ -395,10 +417,12 @@ file_actions_last_opened_update (GimpContainer   *container,
       else
         {
           g_object_set (action,
-                        "label",    name,
-                        "tooltip",  NULL,
-                        "visible",  FALSE,
-                        "viewable", NULL,
+                        "label",           name,
+                        "tooltip",         NULL,
+                        "visible",         FALSE,
+                        "viewable",        NULL,
+                        "ellipsize",       PANGO_ELLIPSIZE_MIDDLE,
+                        "max-width-chars", 40,
                         NULL);
         }
 

app/actions/filters-actions.c

@@ -804,7 +804,6 @@ filters_actions_setup (GimpActionGroup *group)
           g_free (action_name);
           action_name = g_strdup_printf ("filters-%s-%d", formatted_op_name, i++);
         }
-      g_free (formatted_op_name);
 
       title   = gegl_operation_class_get_key (op_class, "title");
       op_name = op_class->name;
@@ -824,6 +823,13 @@ filters_actions_setup (GimpActionGroup *group)
       entry.value     = op_class->name;
       entry.help_id   = GIMP_HELP_TOOL_GEGL;
 
+      if (gegl_operation_class_get_key (op_class, "gimp:menu-path") &&
+          g_str_has_prefix (op_class->name, "gegl:"))
+        /* We automatically create an help ID from the operation name
+         * for all core GEGL operations with a menu path key.
+         */
+        entry.help_id = formatted_op_name;
+
       gimp_action_group_add_string_actions (group, "filters-action",
                                             &entry, 1,
                                             filters_apply_interactive_cmd_callback);
@@ -856,6 +862,7 @@ filters_actions_setup (GimpActionGroup *group)
 
       g_free (label);
       g_free (action_name);
+      g_free (formatted_op_name);
     }
 
   g_object_set_data_full (G_OBJECT (group),
@@ -1259,12 +1266,26 @@ filters_actions_history_changed (Gimp            *gimp,
         sensitive = gimp_action_get_sensitive (actual_action, NULL);
 
       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),
+                    /* It is very important that "visible" is set at the
+                     * end, because the docs says that:
+                     *
+                     * > "notify" signals are queued and only emitted (in reverse order) after all properties have been set.
+                     *
+                     * If "visible" is set before "label" in particular,
+                     * we end up in the inconsistent situation where the
+                     * "visible" callbacks have not been run yet, so
+                     * menus don't have the corresponding item whereas
+                     * the action already shows as visible. In
+                     * particular, g_menu_model_items_changed() may
+                     * crash on an empty item list in GIMP_GTK_MENUBAR
+                     * codepath.
+                     */
+                    "visible",   TRUE,
                     NULL);
     }
 

app/actions/gimpgeglprocedure.c

@@ -48,6 +48,12 @@
 #include "core/gimpsettings.h"
 #include "core/gimptoolinfo.h"
 
+#include "widgets/gimpaction.h"
+#include "widgets/gimpactiongroup.h"
+#include "widgets/gimphelp-ids.h"
+#include "widgets/gimpstringaction.h"
+#include "widgets/gimpuimanager.h"
+
 #include "tools/gimpoperationtool.h"
 #include "tools/tool_manager.h"
 
@@ -64,6 +70,7 @@ static gint64   gimp_gegl_procedure_get_memsize         (GimpObject     *object,
 static gchar  * gimp_gegl_procedure_get_description     (GimpViewable   *viewable,
                                                          gchar         **tooltip);
 
+static const gchar * gimp_gegl_procedure_get_help_id    (GimpProcedure  *procedure);
 static const gchar * gimp_gegl_procedure_get_menu_label (GimpProcedure  *procedure);
 static gboolean      gimp_gegl_procedure_get_sensitive  (GimpProcedure  *procedure,
                                                          GimpObject     *object,
@@ -103,6 +110,7 @@ gimp_gegl_procedure_class_init (GimpGeglProcedureClass *klass)
   viewable_class->default_icon_name = "gimp-gegl";
   viewable_class->get_description   = gimp_gegl_procedure_get_description;
 
+  proc_class->get_help_id           = gimp_gegl_procedure_get_help_id;
   proc_class->get_menu_label        = gimp_gegl_procedure_get_menu_label;
   proc_class->get_sensitive         = gimp_gegl_procedure_get_sensitive;
   proc_class->execute               = gimp_gegl_procedure_execute;
@@ -153,6 +161,41 @@ gimp_gegl_procedure_get_description (GimpViewable  *viewable,
   return g_strdup (gimp_procedure_get_label (procedure));
 }
 
+static const gchar *
+gimp_gegl_procedure_get_help_id (GimpProcedure *procedure)
+{
+  GimpGeglProcedure *proc = GIMP_GEGL_PROCEDURE (procedure);
+  GList             *managers;
+  GimpActionGroup   *group;
+  const gchar       *help_id = NULL;
+
+  managers = gimp_ui_managers_from_name ("<Image>");
+  group    = gimp_ui_manager_get_action_group (managers->data, "filters");
+
+  if (procedure->help_id)
+    {
+      return procedure->help_id;
+    }
+  else if (group)
+    {
+      GList *actions;
+      GList *iter;
+
+      actions = gimp_action_group_list_actions (group);
+      for (iter = actions; iter; iter = iter->next)
+        if (GIMP_IS_STRING_ACTION (iter->data) &&
+            g_strcmp0 (GIMP_STRING_ACTION (iter->data)->value, proc->operation) == 0)
+          {
+            help_id = gimp_action_get_help_id (iter->data);
+            break;
+          }
+
+      g_list_free (actions);
+    }
+
+  return help_id == NULL ? GIMP_HELP_TOOL_GEGL : help_id;
+}
+
 static const gchar *
 gimp_gegl_procedure_get_menu_label (GimpProcedure *procedure)
 {

app/actions/image-actions.c

@@ -85,7 +85,7 @@ static const GimpActionEntry image_actions[] =
     NC_("image-action", "_Soft-proof Profile..."), NULL, { NULL },
     NC_("image-action", "Set the soft-proofing profile"),
     image_softproof_profile_cmd_callback,
-    GIMP_HELP_VIEW_COLOR_MANAGEMENT },
+    GIMP_HELP_IMAGE_SOFT_PROOF_PROFILE_ASSIGN },
 
   { "image-color-profile-save", NULL,
     NC_("image-action", "_Save Color Profile to File..."), NULL, { NULL },
@@ -176,7 +176,7 @@ static const GimpToggleActionEntry image_toggle_actions[] =
     NC_("image-action", "Use black point compensation for soft-proofing"),
     image_softproof_bpc_cmd_callback,
     TRUE,
-    GIMP_HELP_VIEW_COLOR_MANAGEMENT }
+    GIMP_HELP_IMAGE_SOFT_PROOF_BLACK_POINT }
 };
 
 static const GimpRadioActionEntry image_convert_base_type_actions[] =
@@ -299,25 +299,25 @@ static const GimpRadioActionEntry image_softproof_intent_actions[] =
     NC_("image-action", "_Perceptual"), NULL, { NULL },
     NC_("image-action", "Soft-proofing rendering intent is perceptual"),
     GIMP_COLOR_RENDERING_INTENT_PERCEPTUAL,
-    GIMP_HELP_VIEW_COLOR_MANAGEMENT },
+    GIMP_HELP_IMAGE_SOFT_PROOF_RENDERING_INTENT },
 
   { "image-softproof-intent-relative-colorimetric", NULL,
     NC_("image-action", "_Relative Colorimetric"), NULL, { NULL },
     NC_("image-action", "Soft-proofing rendering intent is relative colorimetric"),
     GIMP_COLOR_RENDERING_INTENT_RELATIVE_COLORIMETRIC,
-    GIMP_HELP_VIEW_COLOR_MANAGEMENT },
+    GIMP_HELP_IMAGE_SOFT_PROOF_RENDERING_INTENT },
 
   { "image-softproof-intent-saturation", NULL,
     NC_("image-action", "_Saturation"), NULL, { NULL },
     NC_("image-action", "Soft-proofing rendering intent is saturation"),
     GIMP_COLOR_RENDERING_INTENT_SATURATION,
-    GIMP_HELP_VIEW_COLOR_MANAGEMENT },
+    GIMP_HELP_IMAGE_SOFT_PROOF_RENDERING_INTENT },
 
   { "image-softproof-intent-absolute-colorimetric", NULL,
     NC_("image-action", "_Absolute Colorimetric"), NULL, { NULL },
     NC_("image-action", "Soft-proofing rendering intent is absolute colorimetric"),
     GIMP_COLOR_RENDERING_INTENT_ABSOLUTE_COLORIMETRIC,
-    GIMP_HELP_VIEW_COLOR_MANAGEMENT }
+    GIMP_HELP_IMAGE_SOFT_PROOF_RENDERING_INTENT }
 };
 
 

app/actions/layers-commands.c

@@ -271,6 +271,9 @@ layers_edit_attributes_cmd_callback (GimpAction *action,
 
   layer = layers->data;
 
+  if (gimp_layer_is_floating_sel (layer))
+    return;
+
 #define EDIT_DIALOG_KEY "gimp-layer-edit-attributes-dialog"
 
   dialog = dialogs_get_dialog (G_OBJECT (layer), EDIT_DIALOG_KEY);
@@ -832,6 +835,7 @@ layers_duplicate_cmd_callback (GimpAction *action,
                             gimp_layer_get_parent (iter->data),
                             gimp_item_get_index (iter->data),
                             TRUE);
+      gimp_drawable_enable_resize_undo (GIMP_DRAWABLE (new_layer));
       new_layers = g_list_prepend (new_layers, new_layer);
 
       /* Import any attached layer effects */
@@ -943,11 +947,47 @@ layers_merge_group_cmd_callback (GimpAction *action,
 
           for (iter2 = layers; iter2; iter2 = iter2->next)
             {
+              if (iter->data == iter2->data)
+                continue;
+
               /* Do not merge a layer when we already merge one of its
                * ancestors.
                */
               if (gimp_viewable_is_ancestor (iter2->data, iter->data))
                 break;
+
+              /* Do not merge a layer which has a little sister (same
+               * parent and smaller index) or a little cousin (one of
+               * its ancestors is a little sister) of a pass-through
+               * group layer.
+               * These will be rendered and merged through the
+               * pass-through by definition.
+               */
+              if (gimp_viewable_get_children (GIMP_VIEWABLE (iter2->data)) &&
+                  gimp_layer_get_mode (iter2->data) == GIMP_LAYER_MODE_PASS_THROUGH)
+                {
+                  GimpLayer *pass_through_parent = gimp_layer_get_parent (iter2->data);
+                  GimpLayer *cousin              = iter->data;
+                  gboolean   ignore = FALSE;
+
+                  do
+                    {
+                      GimpLayer *cousin_parent = gimp_layer_get_parent (cousin);
+
+                      if (pass_through_parent == cousin_parent &&
+                          gimp_item_get_index (GIMP_ITEM (iter2->data)) < gimp_item_get_index (GIMP_ITEM (cousin)))
+                        {
+                          ignore = TRUE;
+                          break;
+                        }
+
+                      cousin = cousin_parent;
+                    }
+                  while (cousin != NULL);
+
+                  if (ignore)
+                    break;
+                }
             }
 
           if (iter2 == NULL)
@@ -999,7 +1039,7 @@ layers_delete_cmd_callback (GimpAction *action,
   removed_layers = g_list_copy (layers);
 
   /* Removing children layers (they will be removed anyway by removing
-   * the parent.
+   * the parent).
    */
   for (iter = removed_layers; iter; iter = iter->next)
     {

app/actions/plug-in-actions.c

@@ -117,9 +117,7 @@ plug_in_actions_update (GimpActionGroup *group,
     {
       GimpPlugInProcedure *proc = list->data;
 
-      if (proc->menu_label  &&
-          ! proc->file_proc &&
-          proc->image_types_val)
+      if (proc->menu_label && ! proc->file_proc)
         {
           GimpProcedure *procedure = GIMP_PROCEDURE (proc);
           gboolean       sensitive;

app/actions/procedure-commands.c

@@ -24,6 +24,8 @@
 
 #include "actions-types.h"
 
+#include "operations/gimpoperationsettings.h"
+
 #include "core/gimp.h"
 #include "core/gimpimage.h"
 #include "core/gimpdrawable.h"
@@ -309,9 +311,13 @@ procedure_commands_get_display_args (GimpProcedure *procedure,
         }
     }
 
+  /* Some filters have a settings object (see filters_settings_actions
+   * list), which we want to pass around, but we don't want to pass
+   * other types of object data.
+   */
   if (gimp_value_array_length (args) > n_args &&
       g_type_is_a (G_PARAM_SPEC_VALUE_TYPE (procedure->args[n_args]),
-                   GIMP_TYPE_OBJECT))
+                   GIMP_TYPE_OPERATION_SETTINGS))
     {
       g_value_set_object (gimp_value_array_index (args, n_args), settings);
       n_args++;

app/actions/view-actions.c

@@ -146,7 +146,7 @@ static const GimpActionEntry view_actions[] =
     NC_("view-action",
         "Reset color management to what's configured in preferences"),
     view_color_management_reset_cmd_callback,
-    GIMP_HELP_VIEW_COLOR_MANAGEMENT },
+    GIMP_HELP_VIEW_COLOR_MANAGEMENT_RESET },
 
   { "view-shrink-wrap", GIMP_ICON_VIEW_SHRINK_WRAP,
     NC_("view-action", "Shrink _Wrap"), NULL, { "<primary>J", NULL },
@@ -183,21 +183,21 @@ static const GimpToggleActionEntry view_toggle_actions[] =
     NC_("view-action", "Use color management for this view"),
     view_color_management_enable_cmd_callback,
     TRUE,
-    GIMP_HELP_VIEW_COLOR_MANAGEMENT },
+    GIMP_HELP_VIEW_COLOR_MANAGE_VIEW },
 
   { "view-color-management-softproof", NULL,
     NC_("view-action", "_Proof Colors"), NULL, { NULL },
     NC_("view-action", "Use this view for soft-proofing"),
     view_color_management_softproof_cmd_callback,
     FALSE,
-    GIMP_HELP_VIEW_COLOR_MANAGEMENT },
+    GIMP_HELP_VIEW_SOFT_PROOF_VIEW },
 
   { "view-display-black-point-compensation", NULL,
     NC_("view-action", "_Black Point Compensation"), NULL, { NULL },
     NC_("view-action", "Use black point compensation for image display"),
     view_display_bpc_cmd_callback,
     TRUE,
-    GIMP_HELP_VIEW_COLOR_MANAGEMENT },
+    GIMP_HELP_VIEW_SOFT_PROOF_BLACK_POINT },
 
   { "view-softproof-gamut-check", NULL,
     NC_("view-action", "_Mark Out Of Gamut Colors"), NULL, { NULL },
@@ -205,7 +205,7 @@ static const GimpToggleActionEntry view_toggle_actions[] =
         "be represented in the target color space"),
     view_softproof_gamut_check_cmd_callback,
     FALSE,
-    GIMP_HELP_VIEW_COLOR_MANAGEMENT },
+    GIMP_HELP_VIEW_MARK_OUT_OF_GAMUT },
 
   { "view-show-selection", NULL,
     NC_("view-action", "Show _Selection"), NULL, { "<primary>T", NULL },
@@ -522,25 +522,25 @@ static const GimpRadioActionEntry view_display_intent_actions[] =
     NC_("view-action", "_Perceptual"), NULL, { NULL },
     NC_("view-action", "Display rendering intent is perceptual"),
     GIMP_COLOR_RENDERING_INTENT_PERCEPTUAL,
-    GIMP_HELP_VIEW_COLOR_MANAGEMENT },
+    GIMP_HELP_VIEW_SOFT_PROOF_RENDERING_INTENT },
 
   { "view-display-intent-relative-colorimetric", NULL,
     NC_("view-action", "_Relative Colorimetric"), NULL, { NULL },
     NC_("view-action", "Display rendering intent is relative colorimetric"),
     GIMP_COLOR_RENDERING_INTENT_RELATIVE_COLORIMETRIC,
-    GIMP_HELP_VIEW_COLOR_MANAGEMENT },
+    GIMP_HELP_VIEW_SOFT_PROOF_RENDERING_INTENT },
 
   { "view-display-intent-saturation", NULL,
     NC_("view-action", "_Saturation"), NULL, { NULL },
     NC_("view-action", "Display rendering intent is saturation"),
     GIMP_COLOR_RENDERING_INTENT_SATURATION,
-    GIMP_HELP_VIEW_COLOR_MANAGEMENT },
+    GIMP_HELP_VIEW_SOFT_PROOF_RENDERING_INTENT },
 
   { "view-display-intent-absolute-colorimetric", NULL,
     NC_("view-action", "_Absolute Colorimetric"), NULL, { NULL },
     NC_("view-action", "Display rendering intent is absolute colorimetric"),
     GIMP_COLOR_RENDERING_INTENT_ABSOLUTE_COLORIMETRIC,
-    GIMP_HELP_VIEW_COLOR_MANAGEMENT }
+    GIMP_HELP_VIEW_SOFT_PROOF_RENDERING_INTENT }
 };
 
 static const GimpEnumActionEntry view_padding_color_actions[] =

app/actions/windows-actions.c

@@ -451,6 +451,11 @@ windows_actions_update_display_accels (GimpActionGroup *group)
           gchar       *tooltip;
           gchar       *accel;
 
+          g_object_set (action,
+                        "ellipsize",       PANGO_ELLIPSIZE_MIDDLE,
+                        "max-width-chars", 40,
+                        NULL);
+
           if (i < 9)
             accel = gtk_accelerator_name (GDK_KEY_1 + i, GDK_MOD1_MASK);
           else

app/app.c

@@ -88,8 +88,6 @@ static void       app_init_update_noop       (const gchar        *text1,
                                               gdouble             percentage);
 static void       app_activate_callback      (GimpCoreApp        *app,
                                               gpointer            user_data);
-static void       app_restore_after_callback (Gimp               *gimp,
-                                              GimpInitStatusFunc  status_callback);
 static gboolean   app_exit_after_callback    (Gimp               *gimp,
                                               gboolean            kill_it,
                                               GApplication       *app);
@@ -106,11 +104,6 @@ GType gimp_convert_dither_type_compat_get_type (void); /* compat cruft */
 #endif
 
 
-/*  local variables  */
-
-static GObject *initial_monitor = NULL;
-
-
 /*  public functions  */
 
 void
@@ -306,14 +299,6 @@ app_run (const gchar         *full_prog_name,
   /*  initialize lowlevel stuff  */
   gimp_gegl_init (gimp);
 
-  /*  Connect our restore_after callback before gui_init() connects
-   *  theirs, so ours runs first and can grab the initial monitor
-   *  before the GUI's restore_after callback resets it.
-   */
-  g_signal_connect_after (gimp, "restore",
-                          G_CALLBACK (app_restore_after_callback),
-                          NULL);
-
   g_signal_connect_after (gimp, "exit",
                           G_CALLBACK (app_exit_after_callback),
                           app);
@@ -439,7 +424,7 @@ app_activate_callback (GimpCoreApp *app,
                                               NULL,
                                               file,
                                               gimp_core_app_get_as_new (app),
-                                              initial_monitor,
+                                              NULL,
                                               &status, &error);
               if (image)
                 {
@@ -494,7 +479,7 @@ app_activate_callback (GimpCoreApp *app,
 
           file_open_from_command_line (gimp, file,
                                        gimp_core_app_get_as_new (app),
-                                       initial_monitor);
+                                       NULL);
 
           g_object_unref (file);
         }
@@ -554,20 +539,6 @@ app_activate_callback (GimpCoreApp *app,
     }
 }
 
-static void
-app_restore_after_callback (Gimp               *gimp,
-                            GimpInitStatusFunc  status_callback)
-{
-  gint dummy;
-
-  /*  Getting the display name for a -1 display returns the initial
-   *  monitor during startup. Need to call this from a restore_after
-   *  callback, because before restore(), the GUI can't return anything,
-   *  after after restore() the initial monitor gets reset.
-   */
-  g_free (gimp_get_display_name (gimp, -1, &initial_monitor, &dummy));
-}
-
 static gboolean
 app_exit_after_callback (Gimp         *gimp,
                          gboolean      kill_it,
@@ -576,29 +547,8 @@ app_exit_after_callback (Gimp         *gimp,
   if (gimp->be_verbose)
     g_print ("EXIT: %s\n", G_STRFUNC);
 
-  /*
-   *  In releases, we simply call exit() here. This speeds up the
-   *  process of quitting GIMP and also works around the problem that
-   *  plug-ins might still be running.
-   *
-   *  In unstable releases, we shut down GIMP properly in an attempt
-   *  to catch possible problems in our finalizers.
-   */
-
-#ifdef GIMP_RELEASE
-
-  gimp_gegl_exit (gimp);
-
-  gegl_exit ();
-
-  exit (gimp_core_app_get_exit_status (GIMP_CORE_APP (app)));
-
-#else
-
   g_application_quit (G_APPLICATION (app));
 
-#endif
-
   return FALSE;
 }
 

app/config/gimpconfig-dump.c

@@ -506,15 +506,13 @@ dump_describe_param (GParamSpec *param_spec)
     }
   else if (GIMP_IS_PARAM_SPEC_UNIT (param_spec))
     {
-      GimpParamSpecUnit *uspec = GIMP_PARAM_SPEC_UNIT (param_spec);
-
-      if (uspec->allow_pixel && uspec->allow_percent)
+      if (gimp_param_spec_unit_pixel_allowed (param_spec) && gimp_param_spec_unit_percent_allowed (param_spec))
         values = "The unit can be one inches, millimeters, points or picas plus "
                  "those in your user units database. Pixel And Percent units are allowed too.";
-      else if (uspec->allow_pixel)
+      else if (gimp_param_spec_unit_pixel_allowed (param_spec))
         values = "The unit can be one inches, millimeters, points or picas plus "
                  "those in your user units database. Pixel unit is allowed too.";
-      else if (uspec->allow_percent)
+      else if (gimp_param_spec_unit_percent_allowed (param_spec))
         values = "The unit can be one inches, millimeters, points or picas plus "
                  "those in your user units database. Percent unit is allowed too.";
       else

app/core/gimp-edit.c

@@ -136,8 +136,9 @@ gimp_edit_cut (GimpImage     *image,
 
           /* Remove layers from source image. */
           for (iter = drawables; iter; iter = iter->next)
-            gimp_image_remove_layer (image, GIMP_LAYER (iter->data),
-                                     TRUE, NULL);
+            if (! gimp_layer_is_floating_sel (iter->data))
+              gimp_image_remove_layer (image, GIMP_LAYER (iter->data),
+                                       TRUE, NULL);
 
           g_list_free (drawables);
         }
@@ -285,7 +286,6 @@ gimp_edit_copy (GimpImage     *image,
       clip_image = gimp_image_new_from_drawables (image->gimp, drawables, TRUE, TRUE);
       gimp_container_remove (image->gimp->images, GIMP_OBJECT (clip_image));
       gimp_set_clipboard_image (image->gimp, clip_image);
-      g_object_unref (clip_image);
       g_list_free (drawables);
 
       clip_selection = gimp_image_get_mask (clip_image);
@@ -339,10 +339,14 @@ gimp_edit_copy (GimpImage     *image,
             }
           g_list_free (all_items);
 
-          /* We need to keep the image size as-is, because even after cropping
-           * layers to selection, their offset stay important for in-place paste
-           * variants. Yet we also need to store the dimensions where we'd have
-           * cropped the image for the "Paste as New Image" action.
+          gimp_image_undo_disable (clip_image);
+          gimp_image_resize_to_layers (clip_image, context, NULL, NULL, NULL,
+                                       NULL, NULL);
+          gimp_image_undo_enable (clip_image);
+
+          /* We need to store the original offsets before the image was
+           * resized, in order to move it into the correct location for
+           * in-place pasting.
            */
           g_object_set_data (G_OBJECT (clip_image),
                              "gimp-edit-new-image-x",
@@ -350,15 +354,10 @@ gimp_edit_copy (GimpImage     *image,
           g_object_set_data (G_OBJECT (clip_image),
                              "gimp-edit-new-image-y",
                              GINT_TO_POINTER (selection_bounds.y));
-          g_object_set_data (G_OBJECT (clip_image),
-                             "gimp-edit-new-image-width",
-                             GINT_TO_POINTER (selection_bounds.width));
-          g_object_set_data (G_OBJECT (clip_image),
-                             "gimp-edit-new-image-height",
-                             GINT_TO_POINTER (selection_bounds.height));
         }
       /* Remove selection from the clipboard image. */
       gimp_channel_clear (clip_selection, NULL, FALSE);
+      g_object_unref (clip_image);
 
       return GIMP_OBJECT (gimp_get_clipboard_image (image->gimp));
     }
@@ -1062,7 +1061,16 @@ gimp_edit_paste (GimpImage     *image,
 
   if (gimp_edit_paste_is_in_place (paste_type))
     {
-      if (GIMP_IS_BUFFER (paste))
+      offset_x = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (paste),
+                                                     "gimp-edit-new-image-x"));
+      offset_y = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (paste),
+                                                     "gimp-edit-new-image-y"));
+
+      if (offset_x != 0 || offset_y != 0)
+        {
+          use_offset = TRUE;
+        }
+      else if (GIMP_IS_BUFFER (paste))
         {
           GimpBuffer *buffer = GIMP_BUFFER (paste);
 
@@ -1101,35 +1109,9 @@ gimp_edit_paste_as_new_image (Gimp        *gimp,
   g_return_val_if_fail (GIMP_IS_IMAGE (paste) || GIMP_IS_BUFFER (paste), NULL);
 
   if (GIMP_IS_IMAGE (paste))
-    {
-      gint offset_x;
-      gint offset_y;
-      gint new_width;
-      gint new_height;
-
-      offset_x   = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (paste),
-                                                       "gimp-edit-new-image-x"));
-      offset_y   = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (paste),
-                                                       "gimp-edit-new-image-y"));
-      new_width  = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (paste),
-                                                       "gimp-edit-new-image-width"));
-      new_height = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (paste),
-                                                       "gimp-edit-new-image-height"));
-      image = gimp_image_duplicate (GIMP_IMAGE (paste));
-      if (new_width > 0 && new_height > 0)
-        {
-          gimp_image_undo_disable (image);
-          gimp_image_resize (image, context,
-                             new_width, new_height,
-                             -offset_x, -offset_y,
-                             NULL);
-          gimp_image_undo_enable (image);
-        }
-    }
+    image = gimp_image_duplicate (GIMP_IMAGE (paste));
   else if (GIMP_IS_BUFFER (paste))
-    {
-      image = gimp_image_new_from_buffer (gimp, GIMP_BUFFER (paste));
-    }
+    image = gimp_image_new_from_buffer (gimp, GIMP_BUFFER (paste));
 
   return image;
 }

app/core/gimp-user-install.c

@@ -952,6 +952,7 @@ user_update_sessionrc (const GMatchInfo *matched_value,
 }
 
 #define GIMPRC_UPDATE_PATTERN \
+  "\\(show-tooltips [^)]*\\)"  "|" \
   "\\(theme [^)]*\\)"          "|" \
   "^ *\\(.*-path \".*\"\\) *$" "|" \
   "\\(style solid\\)"          "|" \
@@ -983,6 +984,8 @@ user_update_gimprc (const GMatchInfo *matched_value,
     }
   else
     {
+      /* Do not migrate show-tooltips GIMP < 3.0. Cf. #1965. */
+
       /* Do not migrate paths and themes from GIMP < 3.0. */
 
       /* Do not migrate the advanced color options which was the gamma

app/core/gimp-utils.c

@@ -745,31 +745,54 @@ gimp_file_is_executable (GFile *file)
 gchar *
 gimp_file_get_extension (GFile *file)
 {
-  gchar *uri;
-  gint   uri_len;
-  gchar *ext = NULL;
-  gint   search_len;
+  GFileInfo *info;
+  gchar     *basename;
+  gint       basename_len;
+  gchar     *ext = NULL;
+  gint       search_len;
 
   g_return_val_if_fail (G_IS_FILE (file), NULL);
 
-  uri     = g_file_get_uri (file);
-  uri_len = strlen (uri);
+  /* Certain cloud providers return a blob name rather than the
+   * actual file with g_file_get_uri (). Since we don't check
+   * the magic numbers for remote files, we can't open it. The
+   * actual name is stored as "display-name" in all cases, so we
+   * use that instead. */
+  info = g_file_query_info (file,
+                            G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME,
+                            0, NULL, NULL);
 
-  if (g_str_has_suffix (uri, ".gz"))
-    search_len = uri_len - 3;
-  else if (g_str_has_suffix (uri, ".bz2"))
-    search_len = uri_len - 4;
-  else if (g_str_has_suffix (uri, ".xz"))
-    search_len = uri_len - 3;
+  if (info != NULL)
+    basename =
+      g_file_info_get_attribute_as_string (info,
+                                           G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME);
   else
-    search_len = uri_len;
+    basename = g_file_get_basename (file);
 
-  ext = g_strrstr_len (uri, search_len, ".");
+  g_clear_object (&info);
+
+  /* When making a temporary file for saving/exporting, we may not
+   * have the display-name yet, so let's fallback to the URI */
+  if (! basename)
+    basename = g_file_get_uri (file);
+
+  basename_len = strlen (basename);
+
+  if (g_str_has_suffix (basename, ".gz"))
+    search_len = basename_len - 3;
+  else if (g_str_has_suffix (basename, ".bz2"))
+    search_len = basename_len - 4;
+  else if (g_str_has_suffix (basename, ".xz"))
+    search_len = basename_len - 3;
+  else
+    search_len = basename_len;
+
+  ext = g_strrstr_len (basename, search_len, ".");
 
   if (ext)
     ext = g_strdup (ext);
 
-  g_free (uri);
+  g_free (basename);
 
   return ext;
 }

app/core/gimp.c

@@ -63,6 +63,7 @@
 #include "gimpgradient.h"
 #include "gimpidtable.h"
 #include "gimpimage.h"
+#include "gimpimage-metadata.h"
 #include "gimpimagefile.h"
 #include "gimplist.h"
 #include "gimpmarshal.h"
@@ -373,8 +374,6 @@ gimp_dispose (GObject *object)
   g_clear_object (&gimp->edit_config);
   g_clear_object (&gimp->config);
 
-  gimp_contexts_exit (gimp);
-
   g_clear_object (&gimp->image_new_last_template);
 
   G_OBJECT_CLASS (parent_class)->dispose (object);
@@ -912,6 +911,8 @@ gimp_exit (Gimp     *gimp,
   if (handled)
     return;
 
+  gimp_contexts_exit (gimp);
+
   g_idle_add_full (G_PRIORITY_LOW,
                    (GSourceFunc) gimp_exit_idle_cleanup_stray_images,
                    gimp, NULL);
@@ -1036,12 +1037,17 @@ gimp_create_image (Gimp              *gimp,
                    GimpPrecision      precision,
                    gboolean           attach_comment)
 {
-  GimpImage *image;
+  GimpImage    *image;
+  GimpMetadata *metadata;
 
   g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
 
   image = gimp_image_new (gimp, width, height, type, precision);
 
+  metadata = gimp_metadata_new ();
+  gimp_image_set_metadata (image, metadata, FALSE);
+  g_object_unref (metadata);
+
   if (attach_comment)
     {
       const gchar *comment;

app/core/gimpbrush-load.c

@@ -905,9 +905,10 @@ gimp_brush_load_abr_brush_v6 (GDataInputStream  *input,
               width, height, depth, compress);
 #endif
 
-  if (width  < 1 || width  > 10000 ||
-      height < 1 || height > 10000 ||
-      depth  < 1 || depth  > 1     ||
+  if (width  < 1 || width  > 10000             ||
+      height < 1 || height > 10000             ||
+      (compress && depth != 1)                 ||
+      (! compress && (depth < 1 || depth > 2)) ||
       G_MAXSIZE / width / height / depth < 1)
     {
       g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
@@ -952,13 +953,43 @@ gimp_brush_load_abr_brush_v6 (GDataInputStream  *input,
       /* not compressed - read raw bytes as brush data */
       gsize bytes_read;
 
-      if (! g_input_stream_read_all (G_INPUT_STREAM (input),
-                                     mask, size,
-                                     &bytes_read, NULL, error) ||
-          bytes_read != size)
+      if (depth == 1)
         {
-          g_object_unref (brush);
-          return NULL;
+          if (! g_input_stream_read_all (G_INPUT_STREAM (input),
+                                         mask, size,
+                                         &bytes_read, NULL, error) ||
+              bytes_read != size)
+            {
+              g_object_unref (brush);
+              return NULL;
+            }
+        }
+      else if (depth == 2)
+        {
+          /* TODO: For now, convert to 8 bit representation */
+          guchar *mask_f = g_new0 (guchar, width * height * depth);
+
+          if (! g_input_stream_read_all (G_INPUT_STREAM (input),
+                                         mask_f, size,
+                                         &bytes_read, NULL, error) ||
+              bytes_read != size)
+            {
+              g_object_unref (brush);
+              g_free (mask_f);
+              return NULL;
+            }
+
+          for (gint i = 0; i < size; i += 2)
+            {
+              guint16 *temp   = (guint16 *) &mask_f[i];
+              gfloat   temp_f = (gfloat) GUINT16_FROM_LE (temp[0]);
+
+              temp_f = CLAMP (temp_f / G_MAXUINT16, 0.0, 1.0);
+
+              mask[i / 2] = (guchar) (temp_f * 255);
+            }
+
+          g_free (mask_f);
         }
     }
   else

app/core/gimpbrushclipboard.c

@@ -31,8 +31,11 @@
 #include "gimpbuffer.h"
 #include "gimpbrush-private.h"
 #include "gimpbrushclipboard.h"
+#include "gimpchannel.h"
+#include "gimpcontext.h"
 #include "gimpimage.h"
 #include "gimppickable.h"
+#include "gimpselection.h"
 #include "gimptempbuf.h"
 
 #include "gimp-intl.h"
@@ -203,7 +206,8 @@ gimp_brush_clipboard_changed (Gimp      *gimp,
                               GimpBrush *brush)
 {
   GimpObject *paste;
-  GeglBuffer *buffer = NULL;
+  GeglBuffer *buffer       = NULL;
+  gboolean    unref_buffer = FALSE;
   gint        width;
   gint        height;
 
@@ -214,8 +218,37 @@ gimp_brush_clipboard_changed (Gimp      *gimp,
 
   if (GIMP_IS_IMAGE (paste))
     {
+      GimpContext *context = gimp_get_user_context (gimp);
+
       gimp_pickable_flush (GIMP_PICKABLE (paste));
-      buffer = gimp_pickable_get_buffer (GIMP_PICKABLE (paste));
+      if (context)
+        {
+          GimpChannel *mask = gimp_image_get_mask (GIMP_IMAGE (paste));
+
+          if (! gimp_channel_is_empty (mask))
+            {
+              GList *pickables;
+              gint   offset_x;
+              gint   offset_y;
+
+              pickables = g_list_prepend (NULL, GIMP_IMAGE (paste));
+              buffer = gimp_selection_extract (GIMP_SELECTION (mask),
+                                               pickables, context,
+                                               FALSE, FALSE, FALSE,
+                                               &offset_x, &offset_y,
+                                               NULL);
+              g_list_free (pickables);
+              unref_buffer = TRUE;
+            }
+          else
+            {
+              buffer = gimp_pickable_get_buffer (GIMP_PICKABLE (paste));
+            }
+        }
+      else
+        {
+          buffer = gimp_pickable_get_buffer (GIMP_PICKABLE (paste));
+        }
     }
   else if (GIMP_IS_BUFFER (paste))
     {
@@ -280,6 +313,9 @@ gimp_brush_clipboard_changed (Gimp      *gimp,
                            gimp_temp_buf_get_data (brush->priv->pixmap),
                            GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
         }
+
+      if (unref_buffer)
+        g_object_unref (buffer);
     }
   else
     {

app/core/gimpbrushgenerated.c

@@ -141,7 +141,9 @@ gimp_brush_generated_class_init (GimpBrushGeneratedClass *klass)
   g_object_class_install_property (object_class, PROP_RADIUS,
                                    g_param_spec_double ("radius", NULL,
                                                         _("Brush Radius"),
-                                                        0.1, 4000.0, 5.0,
+                                                        GIMP_BRUSH_GENERATED_MIN_RADIUS,
+                                                        GIMP_BRUSH_GENERATED_MAX_RADIUS,
+                                                        5.0,
                                                         GIMP_PARAM_READWRITE |
                                                         G_PARAM_CONSTRUCT));
 
@@ -733,7 +735,7 @@ gimp_brush_generated_set_radius (GimpBrushGenerated *brush,
 {
   g_return_val_if_fail (GIMP_IS_BRUSH_GENERATED (brush), -1.0);
 
-  radius = CLAMP (radius, 0.0, 32767.0);
+  radius = CLAMP (radius, GIMP_BRUSH_GENERATED_MIN_RADIUS, GIMP_BRUSH_GENERATED_MAX_RADIUS);
 
   if (brush->radius != radius)
     {

app/core/gimpbrushgenerated.h

@@ -32,6 +32,10 @@
 #define GIMP_BRUSH_GENERATED_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_BRUSH_GENERATED, GimpBrushGeneratedClass))
 
 
+/* When changing these values, also update it in pdb/groups/brush.pdb */
+#define GIMP_BRUSH_GENERATED_MIN_RADIUS         0.1
+#define GIMP_BRUSH_GENERATED_MAX_RADIUS      4000.0
+
 typedef struct _GimpBrushGeneratedClass GimpBrushGeneratedClass;
 
 struct _GimpBrushGenerated

app/core/gimpdrawable-edit.c

@@ -194,7 +194,19 @@ gimp_drawable_edit_fill (GimpDrawable    *drawable,
     {
       gimp_drawable_edit_fill_direct (drawable, options, undo_desc);
 
-      gimp_drawable_update (drawable, x, y, width, height);
+      if (gimp_drawable_has_visible_filters (drawable))
+        {
+          /* For drawables with filters, update the bounding box then
+           * let the drawable update everything, because the filtered
+           * render may be bigger than the filled part.
+           */
+          gimp_drawable_update_bounding_box (drawable);
+          gimp_drawable_update (drawable, 0, 0, -1, -1);
+        }
+      else
+        {
+          gimp_drawable_update (drawable, x, y, width, height);
+        }
     }
   else
     {

app/core/gimpdrawable-preview.c

@@ -163,13 +163,10 @@ gimp_drawable_get_preview_format (GimpDrawable *drawable)
 
   switch (gimp_drawable_get_base_type (drawable))
     {
-    case GIMP_GRAY:
-      return gimp_babl_format (GIMP_GRAY,
-                               gimp_babl_precision (GIMP_COMPONENT_TYPE_U8,
-                                                    trc),
-                               alpha, space);
-
     case GIMP_RGB:
+    case GIMP_GRAY:
+      return gimp_drawable_get_format (drawable);
+
     case GIMP_INDEXED:
       return gimp_babl_format (GIMP_RGB,
                                gimp_babl_precision (GIMP_COMPONENT_TYPE_U8,

app/core/gimpdrawable.c

@@ -167,6 +167,7 @@ static void       gimp_drawable_real_update        (GimpDrawable      *drawable,
                                                     gint               width,
                                                     gint               height);
 
+static void    gimp_drawable_real_filters_changed  (GimpDrawable      *drawable);
 static gint64  gimp_drawable_real_estimate_memsize (GimpDrawable      *drawable,
                                                     GimpComponentType  component_type,
                                                     gint               width,
@@ -310,7 +311,7 @@ gimp_drawable_class_init (GimpDrawableClass *klass)
   klass->format_changed           = NULL;
   klass->alpha_changed            = NULL;
   klass->bounding_box_changed     = NULL;
-  klass->filters_changed          = NULL;
+  klass->filters_changed          = gimp_drawable_real_filters_changed;
   klass->estimate_memsize         = gimp_drawable_real_estimate_memsize;
   klass->update_all               = gimp_drawable_real_update_all;
   klass->invalidate_boundary      = NULL;
@@ -763,6 +764,30 @@ gimp_drawable_rotate (GimpItem         *item,
                                      new_off_x, new_off_y, FALSE);
       g_object_unref (buffer);
     }
+
+  if (GIMP_IS_LAYER (drawable))
+    {
+      GList *list;
+      gint   width  = gimp_item_get_width (GIMP_ITEM (drawable));
+      gint   height = gimp_item_get_height (GIMP_ITEM (drawable));
+
+      for (list = GIMP_LIST (drawable->private->filter_stack)->queue->tail;
+           list; list = g_list_previous (list))
+        {
+          if (GIMP_IS_DRAWABLE_FILTER (list->data))
+            {
+              GimpDrawableFilter *filter = list->data;
+              GimpChannel        *mask   = GIMP_CHANNEL (gimp_drawable_filter_get_mask (filter));
+              GeglRectangle       rect   = {0, 0, width, height};
+
+              /* Don't resize partial layer effects */
+              if (gimp_channel_is_empty (mask))
+                gimp_drawable_filter_refresh_crop (filter, &rect);
+            }
+        }
+      if (list)
+        g_list_free (list);
+    }
 }
 
 static void
@@ -871,6 +896,12 @@ gimp_drawable_real_update (GimpDrawable *drawable,
   gimp_viewable_invalidate_preview (GIMP_VIEWABLE (drawable));
 }
 
+static void
+gimp_drawable_real_filters_changed (GimpDrawable *drawable)
+{
+  gimp_drawable_update_bounding_box (drawable);
+}
+
 static gint64
 gimp_drawable_real_estimate_memsize (GimpDrawable      *drawable,
                                      GimpComponentType  component_type,

app/core/gimpdrawablefilter.c

@@ -38,6 +38,8 @@
 
 #include "core-types.h"
 
+#include "operations/gimp-operation-config.h"
+
 #include "gegl/gimp-babl.h"
 #include "gegl/gimpapplicator.h"
 #include "gegl/gimp-gegl-utils.h"
@@ -68,6 +70,8 @@ enum
   PROP_DRAWABLE,
   PROP_MASK,
   PROP_CUSTOM_NAME,
+  PROP_TEMPORARY,
+  PROP_TO_BE_MERGED,
   N_PROPS
 };
 
@@ -110,6 +114,10 @@ struct _GimpDrawableFilter
   GeglNode               *crop_before;
   GeglNode               *crop_after;
   GimpApplicator         *applicator;
+
+  gboolean                is_temporary;
+  /* This is mirroring merge_filter option of GimpFilterOptions. */
+  gboolean                to_be_merged;
 };
 
 static void       gimp_drawable_filter_set_property          (GObject             *object,
@@ -217,6 +225,15 @@ gimp_drawable_filter_class_init (GimpDrawableFilterClass *klass)
                                                                   FALSE,
                                                                   GIMP_PARAM_READWRITE);
 
+  drawable_filter_props[PROP_TEMPORARY] = g_param_spec_boolean ("temporary",
+                                                                NULL, NULL,
+                                                                FALSE,
+                                                                GIMP_PARAM_READWRITE);
+
+  drawable_filter_props[PROP_TO_BE_MERGED] = g_param_spec_boolean ("to-be-merged",
+                                                                   NULL, NULL,
+                                                                   FALSE,
+                                                                   GIMP_PARAM_READWRITE);
 
   g_object_class_install_properties (object_class, N_PROPS, drawable_filter_props);
 }
@@ -273,6 +290,15 @@ gimp_drawable_filter_set_property (GObject      *object,
       filter->has_custom_name = g_value_get_boolean (value);
       break;
 
+    case PROP_TEMPORARY:
+      filter->is_temporary = g_value_get_boolean (value);
+      break;
+
+    case PROP_TO_BE_MERGED:
+      filter->to_be_merged = g_value_get_boolean (value);
+      gimp_drawable_filter_sync_format (filter);
+      break;
+
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
       break;
@@ -298,6 +324,12 @@ gimp_drawable_filter_get_property (GObject    *object,
     case PROP_CUSTOM_NAME:
       g_value_set_boolean (value, filter->has_custom_name);
       break;
+    case PROP_TEMPORARY:
+      g_value_set_boolean (value, filter->is_temporary);
+      break;
+    case PROP_TO_BE_MERGED:
+      g_value_set_boolean (value, filter->to_be_merged);
+      break;
 
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
@@ -754,9 +786,12 @@ gimp_drawable_filter_set_preview_split (GimpDrawableFilter  *filter,
     }
 }
 
-/* This function is mostly for usage by libgimp API. The idea is to have
+/* This function is **ONLY** for usage by libgimp API. The idea is to have
  * a single function which updates a bunch of settings in a single call
  * and in particular a single rendering update.
+ *
+ * Also it does some funky config object switch for custom operations
+ * which is only needed libgimp-side.
  */
 gboolean
 gimp_drawable_filter_update (GimpDrawableFilter      *filter,
@@ -771,8 +806,12 @@ gimp_drawable_filter_update (GimpDrawableFilter      *filter,
                              const GimpDrawable     **auxinputs,
                              GError                 **error)
 {
+  GimpImage    *image;
+  GimpObject   *settings        = NULL;
+  GeglNode     *node            = NULL;
   GParamSpec  **pspecs;
   gchar        *opname;
+  guint         n_parent_pspecs = 0;
   guint         n_pspecs;
   gint          n_values;
   gint          n_auxinputs;
@@ -807,14 +846,55 @@ gimp_drawable_filter_update (GimpDrawableFilter      *filter,
 
   gegl_node_get (filter->operation, "operation", &opname, NULL);
 
-  pspecs = gegl_operation_list_properties (opname, &n_pspecs);
-  for (gint i = 0; i < n_pspecs; i++)
+  image = gimp_item_get_image (GIMP_ITEM (filter->drawable));
+  node  = gimp_drawable_filter_get_operation (filter);
+  if (gimp_operation_config_is_custom (image->gimp, opname))
     {
+      GObjectClass *klass;
+      GObjectClass *parent_klass;
+
+      gegl_node_get (node,
+                     "config", &settings,
+                     NULL);
+      klass        = G_OBJECT_GET_CLASS (settings);
+      parent_klass = G_OBJECT_CLASS (g_type_class_peek_parent (klass));
+      g_free (g_object_class_list_properties (parent_klass, &n_parent_pspecs));
+      pspecs = g_object_class_list_properties (G_OBJECT_GET_CLASS (settings), &n_pspecs);
+    }
+  else
+    {
+      pspecs = gegl_operation_list_properties (opname, &n_pspecs);
+    }
+
+  for (gint i = n_parent_pspecs; i < n_pspecs; i++)
+    {
+      GParamSpec *target_pspec;
       GParamSpec *pspec     = pspecs[i];
       GValue      old_value = G_VALUE_INIT;
       gint        j;
 
-      gegl_node_get_property (filter->operation, pspec->name, &old_value);
+      if (settings)
+        target_pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (settings), pspec->name);
+      else
+        target_pspec = gegl_node_find_property (node, pspec->name);
+      if (! target_pspec)
+        {
+          /* If this ever happens, this is more likely a bug in our
+           * PDB code, unless someone tried to call the PDB procedure
+           * directly with bad data.
+           */
+          g_set_error (error, GIMP_ERROR, GIMP_FAILED,
+                       /* TODO: localize after string freeze. */
+                       "GEGL operation '%s' has been called with a "
+                       "non-existent argument name '%s' (#%d).",
+                       opname, pspec->name, i);
+          break;
+        }
+
+      if (settings)
+        g_object_get_property (G_OBJECT (settings), pspec->name, &old_value);
+      else
+        gegl_node_get_property (node, pspec->name, &old_value);
 
       for (j = 0; j < n_values; j++)
         if (g_strcmp0 (pspec->name, propnames[j]) == 0)
@@ -882,7 +962,10 @@ gimp_drawable_filter_update (GimpDrawableFilter      *filter,
 
           if (g_param_values_cmp (pspec, new_value, &old_value) != 0)
             {
-              gegl_node_set_property (filter->operation, pspec->name, new_value);
+              if (settings)
+                g_object_set_property (G_OBJECT (settings), pspec->name, new_value);
+              else
+                gegl_node_set_property (node, pspec->name, new_value);
               changed = TRUE;
             }
 
@@ -898,7 +981,10 @@ gimp_drawable_filter_update (GimpDrawableFilter      *filter,
 
           g_value_init (&default_value, pspec->value_type);
           g_param_value_set_default (pspec, &default_value);
-          gegl_node_set_property (filter->operation, pspec->name, &default_value);
+          if (settings)
+            g_object_set_property (G_OBJECT (settings), pspec->name, &default_value);
+          else
+            gegl_node_set_property (node, pspec->name, &default_value);
           changed = TRUE;
 
           g_value_unset (&default_value);
@@ -936,7 +1022,7 @@ gimp_drawable_filter_update (GimpDrawableFilter      *filter,
           GeglNode   *src_node;
           GeglBuffer *buffer;
 
-          if (! gegl_node_has_pad (filter->operation, auxinputnames[i]))
+          if (! gegl_node_has_pad (node, auxinputnames[i]))
             {
               g_set_error (error, GIMP_ERROR, GIMP_FAILED,
                            /* TODO: localize after string freeze. */
@@ -949,18 +1035,22 @@ gimp_drawable_filter_update (GimpDrawableFilter      *filter,
 
           buffer = gimp_drawable_get_buffer (GIMP_DRAWABLE (auxinputs[i]));
           g_object_ref (buffer);
-          src_node = gegl_node_new_child (gegl_node_get_parent (filter->operation),
+          src_node = gegl_node_new_child (gegl_node_get_parent (node),
                                           "operation", "gegl:buffer-source",
                                           "buffer",    buffer,
                                           NULL);
           g_object_unref (buffer);
 
-          gegl_node_connect (src_node, "output", filter->operation, auxinputnames[i]);
+          gegl_node_connect (src_node, "output", node, auxinputnames[i]);
         }
     }
 
+  if (settings)
+    gegl_node_set (node, "config", settings, NULL);
+
   g_object_thaw_notify (G_OBJECT (filter));
 
+  g_clear_object (&settings);
   g_free (pspecs);
   g_free (opname);
 
@@ -1022,11 +1112,7 @@ gimp_drawable_filter_set_add_alpha (GimpDrawableFilter *filter,
   if (add_alpha != filter->add_alpha)
     {
       filter->add_alpha = add_alpha;
-
       gimp_drawable_filter_sync_format (filter);
-
-      if (gimp_drawable_filter_is_active (filter))
-        gimp_drawable_filter_update_drawable (filter, NULL);
     }
 }
 
@@ -1298,6 +1384,30 @@ gimp_drawable_filter_sync_clip (GimpDrawableFilter *filter,
 static void
 gimp_drawable_filter_sync_region (GimpDrawableFilter *filter)
 {
+  GimpContainer *filters;
+  gboolean       first_filter = FALSE;
+
+  filters = gimp_drawable_get_filters (filter->drawable);
+
+  /* The first test is because the filter might not be added yet. */
+  if (GIMP_LIST (filters)->queue->tail != NULL &&
+      filter == GIMP_LIST (filters)->queue->tail->data)
+    {
+      GimpDrawableFilter *next_filter = NULL;
+
+      if (GIMP_LIST (filters)->queue->head->next)
+        next_filter = GIMP_LIST (filters)->queue->tail->prev->data;
+
+      if (next_filter)
+        /* If the current filter became the first after a reorder, we
+         * want to re-sync the next filter which was the first filter
+         * just before.
+         */
+        gimp_drawable_filter_sync_region (next_filter);
+
+      first_filter = TRUE;
+    }
+
   if (filter->region == GIMP_FILTER_REGION_SELECTION)
     {
       if (filter->has_input)
@@ -1307,10 +1417,16 @@ gimp_drawable_filter_sync_region (GimpDrawableFilter *filter)
                          "y", (gdouble) -filter->filter_area.y,
                          NULL);
 
-          gegl_node_set (filter->crop_before,
-                         "width",  (gdouble) filter->filter_area.width,
-                         "height", (gdouble) filter->filter_area.height,
-                         NULL);
+          if (first_filter)
+            gegl_node_set (filter->crop_before,
+                           "operation", "gegl:crop",
+                           "width",     (gdouble) filter->filter_area.width,
+                           "height",    (gdouble) filter->filter_area.height,
+                           NULL);
+          else
+            gegl_node_set (filter->crop_before,
+                           "operation", "gegl:nop",
+                           NULL);
         }
 
       if (filter->filter_clip)
@@ -1347,10 +1463,16 @@ gimp_drawable_filter_sync_region (GimpDrawableFilter *filter)
                          "y", (gdouble) 0.0,
                          NULL);
 
-          gegl_node_set (filter->crop_before,
-                         "width",  width,
-                         "height", height,
-                         NULL);
+          if (first_filter)
+            gegl_node_set (filter->crop_before,
+                           "operation", "gegl:crop",
+                           "width",     width,
+                           "height",    height,
+                           NULL);
+          else
+            gegl_node_set (filter->crop_before,
+                           "operation", "gegl:nop",
+                           NULL);
         }
 
       if (filter->filter_clip)
@@ -1528,40 +1650,35 @@ gimp_drawable_filter_sync_affect (GimpDrawableFilter *filter)
 static void
 gimp_drawable_filter_sync_format (GimpDrawableFilter *filter)
 {
-  const Babl    *format = NULL;
-  GimpContainer *filters;
+  const Babl *format = NULL;
+  gboolean    changed;
 
-  filters = gimp_drawable_get_filters (filter->drawable);
-
-  g_return_if_fail (GIMP_LIST (filters)->queue->head != NULL);
-
-  if (filter == GIMP_LIST (filters)->queue->head->data)
+  /* We only convert back to drawable format when the filter is planned
+   * to be merged, to simulate how it would look like once it happens.
+   *
+   * On the other hand, when a filter is meant to stay on the stack,
+   * non-destructively, the output might be higher bit depth and there
+   * is no reason to demote it back.
+   *
+   * XXX: actually we might want to do this after the last layer mode
+   * node, no? Otherwise the display render might be better in some case
+   * than when the whole image is actually flattened into a single
+   * buffer. But maybe that's what some people would want?
+   */
+  if (filter->to_be_merged)
     {
-      /* We only want to convert back to the source format at the very
-       * end, and keep an as-high-bit-depth as possible format during
-       * multi-filter processing.
-       */
-      GimpDrawableFilter *next_filter = NULL;
-
-      if (GIMP_LIST (filters)->queue->head->next)
-        next_filter = GIMP_LIST (filters)->queue->head->next->data;
-
       if (filter->add_alpha                                &&
           (gimp_drawable_supports_alpha (filter->drawable) ||
            filter->override_constraints))
-        {
-          format = gimp_drawable_get_format_with_alpha (filter->drawable);
-        }
+        format = gimp_drawable_get_format_with_alpha (filter->drawable);
       else
-        {
-          format = gimp_drawable_get_format (filter->drawable);
-        }
-
-      if (next_filter)
-        gimp_drawable_filter_sync_format (next_filter);
+        format = gimp_drawable_get_format (filter->drawable);
     }
 
-  gimp_applicator_set_output_format (filter->applicator, format);
+  changed = gimp_applicator_set_output_format (filter->applicator, format);
+
+  if (changed && gimp_drawable_filter_is_active (filter))
+    gimp_drawable_filter_update_drawable (filter, NULL);
 }
 
 static void
@@ -1688,6 +1805,13 @@ gimp_drawable_filter_add_filter (GimpDrawableFilter *filter)
                                G_CALLBACK (gimp_drawable_filter_reorder),
                                filter, 0);
 
+      g_signal_connect_object (G_OBJECT (filter->operation), "notify",
+                               G_CALLBACK (gimp_drawable_filters_changed),
+                               filter->drawable, G_CONNECT_SWAPPED);
+      g_signal_connect_object (G_OBJECT (filter), "active-changed",
+                               G_CALLBACK (gimp_drawable_filters_changed),
+                               filter->drawable, G_CONNECT_SWAPPED);
+
       return TRUE;
     }
 
@@ -1703,6 +1827,10 @@ gimp_drawable_filter_remove_filter (GimpDrawableFilter *filter)
       GimpDrawable  *drawable = filter->drawable;
       GimpContainer *filters;
 
+      g_signal_handlers_disconnect_by_func (G_OBJECT (filter),
+                                            G_CALLBACK (gimp_drawable_filters_changed),
+                                            filter->drawable);
+
       filters = gimp_drawable_get_filters (filter->drawable);
       g_signal_handlers_disconnect_by_func (filters,
                                             G_CALLBACK (gimp_drawable_filter_reorder),
@@ -1862,7 +1990,14 @@ gimp_drawable_filter_reorder (GimpFilterStack    *stack,
 
       g_return_if_fail (GIMP_LIST (stack)->queue->head != NULL);
 
-      if (GIMP_LIST (stack)->queue->head->data != filter)
+      if (GIMP_LIST (stack)->queue->head->data != filter &&
+          /* When there is a floating selection, there will be a
+           * GimpFilter (but not a drawable filter) in the stack.
+           * XXX For now, let's fix the crash (#12851) but eventually we
+           * really want to clean up this list and understand better how
+           * it's organized.
+           */
+          GIMP_IS_DRAWABLE_FILTER (GIMP_LIST (stack)->queue->head->data))
         gimp_drawable_filter_sync_format (GIMP_LIST (stack)->queue->head->data);
     }
 }

app/core/gimpdrawableundo.c

@@ -27,6 +27,7 @@
 #include "gimp-memsize.h"
 #include "gimpimage.h"
 #include "gimpdrawable.h"
+#include "gimpdrawable-filters.h"
 #include "gimpdrawableundo.h"
 
 
@@ -186,13 +187,17 @@ gimp_drawable_undo_pop (GimpUndo            *undo,
                         GimpUndoAccumulator *accum)
 {
   GimpDrawableUndo *drawable_undo = GIMP_DRAWABLE_UNDO (undo);
+  GimpDrawable     *drawable      = GIMP_DRAWABLE (GIMP_ITEM_UNDO (undo)->item);
 
   GIMP_UNDO_CLASS (parent_class)->pop (undo, undo_mode, accum);
 
-  gimp_drawable_swap_pixels (GIMP_DRAWABLE (GIMP_ITEM_UNDO (undo)->item),
+  gimp_drawable_swap_pixels (drawable,
                              drawable_undo->buffer,
                              drawable_undo->x,
                              drawable_undo->y);
+
+  if (gimp_drawable_has_visible_filters (drawable))
+    gimp_drawable_update (drawable, 0, 0, -1, -1);
 }
 
 static void

app/core/gimpgrouplayer.c

@@ -172,6 +172,8 @@ static void            gimp_group_layer_convert_type (GimpLayer         *layer,
                                                       GimpProgress      *progress);
 static GeglNode   * gimp_group_layer_get_source_node (GimpDrawable      *drawable);
 
+static void         gimp_group_layer_filters_changed (GimpDrawable      *drawable);
+
 static void         gimp_group_layer_opacity_changed (GimpLayer         *layer);
 static void  gimp_group_layer_effective_mode_changed (GimpLayer         *layer);
 static void
@@ -301,6 +303,7 @@ gimp_group_layer_class_init (GimpGroupLayerClass *klass)
   drawable_class->estimate_memsize       = gimp_group_layer_estimate_memsize;
   drawable_class->update_all             = gimp_group_layer_update_all;
   drawable_class->get_source_node        = gimp_group_layer_get_source_node;
+  drawable_class->filters_changed        = gimp_group_layer_filters_changed;
 
   layer_class->opacity_changed           = gimp_group_layer_opacity_changed;
   layer_class->effective_mode_changed    = gimp_group_layer_effective_mode_changed;
@@ -1182,6 +1185,15 @@ gimp_group_layer_get_source_node (GimpDrawable *drawable)
   return g_object_ref (private->source_node);
 }
 
+static void
+gimp_group_layer_filters_changed (GimpDrawable *drawable)
+{
+  gimp_layer_update_effective_mode (GIMP_LAYER (drawable));
+
+  if (GIMP_DRAWABLE_CLASS (parent_class)->filters_changed)
+    GIMP_DRAWABLE_CLASS (parent_class)->filters_changed (drawable);
+}
+
 static void
 gimp_group_layer_opacity_changed (GimpLayer *layer)
 {
@@ -1275,6 +1287,7 @@ gimp_group_layer_get_effective_mode (GimpLayer              *layer,
    * cheaper.
    */
   if (gimp_layer_get_mode (layer) == GIMP_LAYER_MODE_PASS_THROUGH &&
+      ! gimp_drawable_has_visible_filters (GIMP_DRAWABLE (layer)) &&
       ! no_pass_through_strength_reduction)
     {
       /* we perform the strength-reduction if:

app/core/gimpimage-duplicate.c

@@ -85,6 +85,9 @@ static void          gimp_image_duplicate_parasites        (GimpImage *image,
                                                             GimpImage *new_image);
 static void          gimp_image_duplicate_color_profile    (GimpImage *image,
                                                             GimpImage *new_image);
+static void          gimp_image_duplicate_simulation_profile
+                                                           (GimpImage *image,
+                                                            GimpImage *new_image);
 
 
 GimpImage *
@@ -118,6 +121,9 @@ gimp_image_duplicate (GimpImage *image)
   gimp_image_duplicate_parasites (image, new_image);
   gimp_image_duplicate_color_profile (image, new_image);
 
+  /*  Copy the simulation profile settings */
+  gimp_image_duplicate_simulation_profile (image, new_image);
+
   /*  Copy the colormap if necessary  */
   gimp_image_duplicate_colormap (image, new_image);
 
@@ -169,6 +175,16 @@ gimp_image_duplicate (GimpImage *image)
   /*  Explicitly mark image as dirty, so that its dirty time is set  */
   gimp_image_dirty (new_image, GIMP_DIRTY_ALL);
 
+  /* XXX Without flushing the duplicated image, we had at least one case
+   * where it wouldn't properly render the image (with empty
+   * pass-through groups with layer effects, which I think is because we
+   * have code believing the group is smaller that it really is, because
+   * of the specificity of pass-through groups). See #13057.
+   * So I'm not entirely happy of calling this here, which feels more
+   * like a workaround than a real fix. But it will do for now.
+   */
+  gimp_image_flush (new_image);
+
   return new_image;
 }
 
@@ -585,3 +601,20 @@ gimp_image_duplicate_color_profile (GimpImage *image,
   gimp_image_set_color_profile (new_image, profile, NULL);
   _gimp_image_set_hidden_profile (new_image, hidden, FALSE);
 }
+
+static void
+gimp_image_duplicate_simulation_profile (GimpImage *image,
+                                         GimpImage *new_image)
+{
+  GimpColorProfile         *profile;
+  GimpColorRenderingIntent  intent;
+  gboolean                  bpc;
+
+  profile = gimp_image_get_simulation_profile (image);
+  intent  = gimp_image_get_simulation_intent (image);
+  bpc     = gimp_image_get_simulation_bpc (image);
+
+  gimp_image_set_simulation_profile (new_image, profile);
+  gimp_image_set_simulation_intent (new_image, intent);
+  gimp_image_set_simulation_bpc (new_image, bpc);
+}

app/core/gimpimage-merge.c

@@ -55,13 +55,15 @@
 #include "gimp-intl.h"
 
 
-static GimpLayer * gimp_image_merge_layers (GimpImage     *image,
-                                            GimpContainer *container,
-                                            GSList        *merge_list,
-                                            GimpContext   *context,
-                                            GimpMergeType  merge_type,
-                                            const gchar   *undo_desc,
-                                            GimpProgress  *progress);
+static GSList    * gimp_image_trim_merge_list (GimpImage     *image,
+                                               GSList        *merge_list);
+static GimpLayer * gimp_image_merge_layers    (GimpImage     *image,
+                                               GimpContainer *container,
+                                               GSList        *merge_list,
+                                               GimpContext   *context,
+                                               GimpMergeType  merge_type,
+                                               const gchar   *undo_desc,
+                                               GimpProgress  *progress);
 
 
 /*  public functions  */
@@ -166,7 +168,8 @@ gimp_image_merge_visible_layers (GimpImage     *image,
 
       if (merge_list)
         {
-          GimpLayer   *layer;
+          GimpLayer *layer;
+
           /* if there's a floating selection, anchor it */
           if (gimp_image_get_floating_selection (image))
             floating_sel_anchor (gimp_image_get_floating_selection (image));
@@ -410,9 +413,12 @@ GimpLayer *
 gimp_image_merge_group_layer (GimpImage      *image,
                               GimpGroupLayer *group)
 {
-  GimpLayer *parent;
-  GimpLayer *layer;
-  gint       index;
+  GimpLayer     *parent;
+  GimpLayer     *layer;
+  GeglBuffer    *pass_through_buffer = NULL;
+  gboolean       is_pass_through     = FALSE;
+  gint           index;
+  GeglRectangle  rect;
 
   g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
   g_return_val_if_fail (GIMP_IS_GROUP_LAYER (group), NULL);
@@ -425,27 +431,18 @@ gimp_image_merge_group_layer (GimpImage      *image,
   parent = gimp_layer_get_parent (GIMP_LAYER (group));
   index  = gimp_item_get_index (GIMP_ITEM (group));
 
-  /* if this is a pass-through group, change its mode to NORMAL *before*
-   * duplicating it, since PASS_THROUGH mode is invalid for regular layers.
-   * see bug #793714.
-   */
-  if (gimp_layer_get_mode (GIMP_LAYER (group)) == GIMP_LAYER_MODE_PASS_THROUGH)
+  is_pass_through = (gimp_layer_get_mode (GIMP_LAYER (group)) == GIMP_LAYER_MODE_PASS_THROUGH &&
+                     gimp_item_get_visible (GIMP_ITEM (group)));
+  if (is_pass_through &&
+      (gimp_layer_get_opacity (GIMP_LAYER (group)) < 1.0 ||
+       ! gimp_drawable_has_visible_filters (GIMP_DRAWABLE (group))))
     {
-      GimpLayerColorSpace    blend_space;
-      GimpLayerColorSpace    composite_space;
-      GimpLayerCompositeMode composite_mode;
+      GimpDrawable  *drawable  = GIMP_DRAWABLE (group);
+      GeglNode      *mode_node = gimp_drawable_get_mode_node (drawable);
 
-      /* keep the group's current blend space, composite space, and composite
-       * mode.
-       */
-      blend_space     = gimp_layer_get_blend_space     (GIMP_LAYER (group));
-      composite_space = gimp_layer_get_composite_space (GIMP_LAYER (group));
-      composite_mode  = gimp_layer_get_composite_mode  (GIMP_LAYER (group));
-
-      gimp_layer_set_mode            (GIMP_LAYER (group), GIMP_LAYER_MODE_NORMAL, TRUE);
-      gimp_layer_set_blend_space     (GIMP_LAYER (group), blend_space,            TRUE);
-      gimp_layer_set_composite_space (GIMP_LAYER (group), composite_space,        TRUE);
-      gimp_layer_set_composite_mode  (GIMP_LAYER (group), composite_mode,         TRUE);
+      rect = gegl_node_get_bounding_box (mode_node);
+      pass_through_buffer = gegl_buffer_new (&rect, gimp_drawable_get_format (drawable));
+      gegl_node_blit_buffer (mode_node, pass_through_buffer, &rect, 0, GEGL_ABYSS_NONE);
     }
 
   /* Merge down filter effects */
@@ -460,6 +457,68 @@ gimp_image_merge_group_layer (GimpImage      *image,
   gimp_image_remove_layer (image, GIMP_LAYER (group), TRUE, NULL);
   gimp_image_add_layer (image, layer, parent, index, TRUE);
 
+  /* Pass-through groups are a very special case. The duplicate works
+   * only if both these points are true:
+   * - The group is at full opacity: with lower opacity, what we want is
+   *   in fact the output of the "gimp:pass-through" mode (similar to
+   *   "gimp:replace") because we can't reproduce the same render
+   *   otherwise. This works well, since anyway the merged layer is
+   *   ensured to be the bottomest one on its own level.
+   * - The group has filters: gimp_drawable_merge_filters() will
+   *   actually set the end-rendering to the drawable (kinda rasterizing
+   *   the group layer).
+   */
+   if (pass_through_buffer)
+    {
+      if (rect.x != 0 || rect.y != 0)
+        {
+          GeglBuffer *buffer;
+
+          buffer = gegl_buffer_new (GEGL_RECTANGLE (0, 0, rect.width, rect.height),
+                                    gimp_drawable_get_format (GIMP_DRAWABLE (layer)));
+          gegl_buffer_copy (pass_through_buffer, &rect, GEGL_ABYSS_NONE,
+                            buffer, GEGL_RECTANGLE (0, 0, rect.width, rect.height));
+          g_object_unref (pass_through_buffer);
+          pass_through_buffer = buffer;
+        }
+      gimp_drawable_set_buffer_full (GIMP_DRAWABLE (layer), FALSE, NULL,
+                                     pass_through_buffer, &rect, TRUE);
+      g_object_unref (pass_through_buffer);
+    }
+
+  /* For pass-through group layers, we must remove all "big sister"
+   * layers, i.e. all layers on the same level below the newly merged
+   * layer, because their render is already integrated in the merged
+   * layer. Therefore keeping them would change the whole image's
+   * rendering.
+   */
+  if (is_pass_through)
+    {
+      GimpContainer *stack;
+      GList         *iter;
+      GList         *new_selected = g_list_prepend (NULL, layer);
+      GList         *to_remove    = NULL;
+      gboolean       remove       = FALSE;
+
+      if (parent)
+        stack = gimp_viewable_get_children (GIMP_VIEWABLE (parent));
+      else
+        stack = gimp_image_get_layers (image);
+
+      for (iter = gimp_item_stack_get_item_iter (GIMP_ITEM_STACK (stack)); iter; iter = iter->next)
+        {
+          if (iter->data == layer)
+            remove = TRUE;
+          else if (remove && gimp_item_get_visible (iter->data))
+            to_remove = g_list_prepend (to_remove, iter->data);
+        }
+
+      for (iter = to_remove; iter; iter = iter->next)
+        gimp_image_remove_layer (image, GIMP_LAYER (iter->data), TRUE, new_selected);
+
+      g_list_free (new_selected);
+    }
+
   gimp_image_undo_group_end (image);
 
   return layer;
@@ -545,6 +604,62 @@ gimp_image_merge_visible_paths (GimpImage  *image,
 
 /*  private functions  */
 
+static GSList *
+gimp_image_trim_merge_list (GimpImage *image,
+                            GSList    *merge_list)
+{
+  GSList *trimmed_list = NULL;
+  GSList *pass_through = NULL;
+
+  for (GSList *iter = merge_list; iter; iter = iter->next)
+    {
+      GimpLayer *layer  = iter->data;
+      gboolean   ignore = FALSE;
+
+      for (GSList *iter2 = pass_through; iter2; iter2 = iter2->next)
+        {
+          GimpLayer *pass_through_parent = gimp_layer_get_parent (iter2->data);
+          GimpLayer *cousin              = layer;
+
+          do
+            {
+              GimpLayer *cousin_parent = gimp_layer_get_parent (cousin);
+
+              if (pass_through_parent == cousin_parent &&
+                  gimp_item_get_index (GIMP_ITEM (iter2->data)) < gimp_item_get_index (GIMP_ITEM (cousin)))
+                {
+                  /* The "cousin" layer is in the same group layer as a
+                   * pass-through group and below it. We don't merge it
+                   * because it will be rendered already through the
+                   * merged pass-through by definition.
+                   */
+                  ignore = TRUE;
+                  break;
+                }
+
+              cousin = cousin_parent;
+            }
+          while (cousin != NULL);
+
+          if (ignore)
+            break;
+        }
+
+      if (! ignore)
+        {
+          trimmed_list = g_slist_append (trimmed_list, layer);
+
+          if (gimp_viewable_get_children (GIMP_VIEWABLE (layer)) &&
+              gimp_layer_get_mode (layer) == GIMP_LAYER_MODE_PASS_THROUGH)
+            pass_through = g_slist_append (pass_through, layer);
+        }
+    }
+
+  g_slist_free (pass_through);
+
+  return trimmed_list;
+}
+
 static GimpLayer *
 gimp_image_merge_layers (GimpImage     *image,
                          GimpContainer *container,
@@ -563,19 +678,23 @@ gimp_image_merge_layers (GimpImage     *image,
   GimpLayer        *bottom_layer;
   GimpLayer        *merge_layer;
   gint              position;
+  gint              n_bottom_removed = 0;
   GeglNode         *node;
   GeglNode         *source_node;
   GeglNode         *flatten_node;
   GeglNode         *offset_node;
   GeglNode         *last_node;
-  GeglNode         *last_node_source;
+  GeglNode         *last_node_source = NULL;
   GimpParasiteList *parasites;
+  GSList           *trimmed_list;
 
   g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
   g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
   g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), NULL);
 
-  top_layer = merge_list->data;
+  trimmed_list = gimp_image_trim_merge_list (image, merge_list);
+
+  top_layer = trimmed_list->data;
   parent    = gimp_layer_get_parent (top_layer);
 
   /*  Make sure the image's graph is constructed, so that top-level layers have
@@ -600,7 +719,7 @@ gimp_image_merge_layers (GimpImage     *image,
   /*  Get the layer extents  */
   x1 = y1 = 0;
   x2 = y2 = 0;
-  for (layers = merge_list; layers; layers = g_slist_next (layers))
+  for (layers = trimmed_list; layers; layers = g_slist_next (layers))
     {
       gint off_x, off_y;
 
@@ -616,7 +735,7 @@ gimp_image_merge_layers (GimpImage     *image,
         {
         case GIMP_EXPAND_AS_NECESSARY:
         case GIMP_CLIP_TO_IMAGE:
-          if (layers == merge_list)
+          if (layers == trimmed_list)
             {
               x1 = off_x;
               y1 = off_y;
@@ -667,7 +786,10 @@ gimp_image_merge_layers (GimpImage     *image,
     }
 
   if ((x2 - x1) == 0 || (y2 - y1) == 0)
-    return NULL;
+    {
+      g_slist_free (trimmed_list);
+      return NULL;
+    }
 
   bottom_layer = layer;
 
@@ -687,6 +809,7 @@ gimp_image_merge_layers (GimpImage     *image,
         {
           g_warning ("%s: could not allocate merge layer", G_STRFUNC);
 
+          g_slist_free (trimmed_list);
           return NULL;
         }
 
@@ -713,6 +836,7 @@ gimp_image_merge_layers (GimpImage     *image,
         {
           g_warning ("%s: could not allocate merge layer", G_STRFUNC);
 
+          g_slist_free (trimmed_list);
           return NULL;
         }
     }
@@ -751,11 +875,16 @@ gimp_image_merge_layers (GimpImage     *image,
       gegl_node_link_many (source_node, offset_node, NULL);
     }
 
-  /*  Disconnect the bottom-layer node's input  */
-  last_node        = gimp_filter_get_node (GIMP_FILTER (bottom_layer));
-  last_node_source = gegl_node_get_producer (last_node, "input", NULL);
+  /*  Disconnect the bottom-layer node's input, unless it's a
+   *  pass-through group.
+   */
+  if (gimp_layer_get_mode (bottom_layer) != GIMP_LAYER_MODE_PASS_THROUGH)
+    {
+      last_node        = gimp_filter_get_node (GIMP_FILTER (bottom_layer));
+      last_node_source = gegl_node_get_producer (last_node, "input", NULL);
 
-  gegl_node_disconnect (last_node, "input");
+      gegl_node_disconnect (last_node, "input");
+    }
 
   /*  Render the graph into the merge layer  */
   gimp_gegl_apply_operation (NULL, progress, undo_desc, offset_node,
@@ -782,9 +911,44 @@ gimp_image_merge_layers (GimpImage     *image,
   gimp_item_set_parasites (GIMP_ITEM (merge_layer), parasites);
   g_object_unref (parasites);
 
-  /*  Remove the merged layers from the image  */
-  for (layers = merge_list; layers; layers = g_slist_next (layers))
-    gimp_image_remove_layer (image, layers->data, TRUE, NULL);
+  for (layers = trimmed_list; layers; layers = g_slist_next (layers))
+    {
+      /* Remove the sisters below merged pass-through group layers. */
+      if (gimp_viewable_get_children (GIMP_VIEWABLE (layers->data)) &&
+          gimp_layer_get_mode (layers->data) == GIMP_LAYER_MODE_PASS_THROUGH)
+        {
+          GimpLayer     *parent;
+          GimpContainer *stack;
+          GList         *iter;
+          gboolean       remove    = FALSE;
+          GList         *to_remove = NULL;
+
+          parent = gimp_layer_get_parent (layers->data);
+          if (parent)
+            stack = gimp_viewable_get_children (GIMP_VIEWABLE (parent));
+          else
+            stack = gimp_image_get_layers (image);
+
+          for (iter = gimp_item_stack_get_item_iter (GIMP_ITEM_STACK (stack)); iter; iter = iter->next)
+            {
+              if (iter->data == layers->data)
+                remove = TRUE;
+              else if (remove && gimp_item_get_visible (GIMP_ITEM (iter->data)))
+                to_remove = g_list_prepend (to_remove, iter->data);
+            }
+
+          if (layers->data == bottom_layer)
+            n_bottom_removed = g_list_length (to_remove);
+
+          for (iter = to_remove; iter; iter = iter->next)
+            gimp_image_remove_layer (image, iter->data, TRUE, NULL);
+
+          g_list_free (to_remove);
+        }
+
+      /*  Remove the merged layers from the image  */
+      gimp_image_remove_layer (image, layers->data, TRUE, NULL);
+    }
 
   gimp_item_set_visible (GIMP_ITEM (merge_layer), TRUE, FALSE);
 
@@ -808,12 +972,13 @@ gimp_image_merge_layers (GimpImage     *image,
     {
       /*  Add the layer to the image  */
       gimp_image_add_layer (image, merge_layer, parent,
-                            gimp_container_get_n_children (container) -
-                            position + 1,
+                            gimp_container_get_n_children (container) +
+                            n_bottom_removed - position + 1,
                             TRUE);
     }
 
   gimp_drawable_update (GIMP_DRAWABLE (merge_layer), 0, 0, -1, -1);
+  g_slist_free (trimmed_list);
 
   return merge_layer;
 }

app/core/gimpimage-new.c

@@ -43,6 +43,7 @@
 #include "gimpimage.h"
 #include "gimpimage-color-profile.h"
 #include "gimpimage-colormap.h"
+#include "gimpimage-metadata.h"
 #include "gimpimage-new.h"
 #include "gimpimage-undo.h"
 #include "gimplayer.h"
@@ -101,6 +102,26 @@ gimp_image_new_set_last_template (Gimp         *gimp,
                     G_OBJECT (gimp->image_new_last_template), 0);
 }
 
+void
+gimp_image_new_add_creation_metadata (GimpImage *image)
+{
+  GimpMetadata *metadata;
+
+  metadata = gimp_image_get_metadata (image);
+  if (! metadata)
+    {
+      g_critical ("Metadata not found. Should not happen!");
+    }
+  else
+    {
+      GDateTime *datetime;
+
+      datetime = g_date_time_new_now_local ();
+      gimp_metadata_set_creation_date (metadata, datetime);
+      g_date_time_unref (datetime);
+    }
+}
+
 GimpImage *
 gimp_image_new_from_template (Gimp         *gimp,
                               GimpTemplate *template,
@@ -182,6 +203,8 @@ gimp_image_new_from_template (Gimp         *gimp,
 
   gimp_image_add_layer (image, layer, NULL, 0, FALSE);
 
+  gimp_image_new_add_creation_metadata (image);
+
   gimp_image_undo_enable (image);
   gimp_image_clean_all (image);
 
@@ -285,6 +308,8 @@ gimp_image_new_from_drawable (Gimp         *gimp,
 
   gimp_image_add_layer (new_image, new_layer, NULL, 0, TRUE);
 
+  gimp_image_new_add_creation_metadata (new_image);
+
   gimp_image_undo_enable (new_image);
 
   return new_image;
@@ -535,6 +560,8 @@ gimp_image_new_from_drawables (Gimp     *gimp,
 
   gimp_image_new_copy_drawables (image, drawables, new_image, tag_copies, NULL, NULL, NULL, NULL);
 
+  gimp_image_new_add_creation_metadata (new_image);
+
   gimp_image_undo_enable (new_image);
 
   return new_image;
@@ -581,6 +608,8 @@ gimp_image_new_from_component (Gimp            *gimp,
 
   gimp_image_add_layer (new_image, layer, NULL, 0, TRUE);
 
+  gimp_image_new_add_creation_metadata (new_image);
+
   gimp_image_undo_enable (new_image);
 
   return new_image;
@@ -630,6 +659,8 @@ gimp_image_new_from_buffer (Gimp       *gimp,
 
   gimp_image_add_layer (image, layer, NULL, 0, TRUE);
 
+  gimp_image_new_add_creation_metadata (image);
+
   gimp_image_undo_enable (image);
 
   return image;
@@ -691,6 +722,8 @@ gimp_image_new_from_pixbuf (Gimp        *gimp,
 
   gimp_image_add_layer (new_image, layer, NULL, 0, TRUE);
 
+  gimp_image_new_add_creation_metadata (new_image);
+
   gimp_image_undo_enable (new_image);
 
   return new_image;

app/core/gimpimage-preview.c

@@ -46,9 +46,7 @@ gimp_image_get_preview_format (GimpImage *image)
     {
     case GIMP_RGB:
     case GIMP_GRAY:
-      return gimp_babl_format_change_component_type (
-        gimp_projectable_get_format (GIMP_PROJECTABLE (image)),
-        GIMP_COMPONENT_TYPE_U8);
+      return gimp_projectable_get_format (GIMP_PROJECTABLE (image));
 
     case GIMP_INDEXED:
       return babl_format ("R'G'B'A u8");

app/core/gimpimage.c

@@ -289,6 +289,8 @@ static gint     gimp_image_layer_stack_cmp         (GList           *layers1,
 static void gimp_image_rec_remove_layer_stack_dups (GimpImage       *image,
                                                     GSList          *start);
 static void     gimp_image_clean_layer_stack       (GimpImage       *image);
+static void     gimp_image_rec_filter_remove_undo  (GimpImage       *image,
+                                                    GimpLayer       *layer);
 static void     gimp_image_remove_from_layer_stack (GimpImage       *image,
                                                     GimpLayer       *layer);
 static gint     gimp_image_selected_is_descendant  (GimpViewable    *selected,
@@ -2030,6 +2032,50 @@ gimp_image_clean_layer_stack (GimpImage *image)
   gimp_image_rec_remove_layer_stack_dups (image, private->layer_stack);
 }
 
+static void
+gimp_image_rec_filter_remove_undo (GimpImage *image,
+                                   GimpLayer *layer)
+{
+  GimpContainer *filters;
+
+  if (gimp_viewable_get_children (GIMP_VIEWABLE (layer)))
+    {
+      GimpContainer *stack = gimp_viewable_get_children (GIMP_VIEWABLE (layer));
+      GList         *children;
+      GList         *iter;
+
+      children = gimp_item_stack_get_item_iter (GIMP_ITEM_STACK (stack));
+
+      for (iter = children; iter; iter = iter->next)
+        {
+          GimpLayer *child = iter->data;
+
+          gimp_image_rec_filter_remove_undo (image, child);
+        }
+    }
+
+  filters = gimp_drawable_get_filters (GIMP_DRAWABLE (layer));
+
+  if (gimp_container_get_n_children (filters) > 0)
+    {
+      GList *filter_list;
+
+      for (filter_list = GIMP_LIST (filters)->queue->tail; filter_list;
+           filter_list = g_list_previous (filter_list))
+        {
+          if (GIMP_IS_DRAWABLE_FILTER (filter_list->data))
+            {
+              GimpDrawableFilter *filter = filter_list->data;
+
+              gimp_image_undo_push_filter_remove (image,
+                                                  _("Remove filter"),
+                                                  GIMP_DRAWABLE (layer),
+                                                  filter);
+            }
+        }
+    }
+}
+
 static void
 gimp_image_remove_from_layer_stack (GimpImage *image,
                                     GimpLayer *layer)
@@ -3141,6 +3187,7 @@ gimp_image_get_xcf_version (GimpImage    *image,
     case 20:
     case 21:
     case 22:
+    case 23:
       if (gimp_version)   *gimp_version   = 300;
       if (version_string) *version_string = "GIMP 3.0";
       break;
@@ -4901,7 +4948,10 @@ gimp_image_set_selected_layers (GimpImage *image,
 
   /*  Make sure the floating_sel always is the active layer  */
   if (floating_sel && (g_list_length (layers2) != 1 || layers2->data != floating_sel))
-    return;
+    {
+      g_list_free (layers2);
+      return;
+    }
 
   selected_layers = gimp_image_get_selected_layers (image);
 
@@ -4920,21 +4970,26 @@ gimp_image_set_selected_layers (GimpImage *image,
 
   if (selection_changed)
     {
+      GList *layers3;
+
       /*  Don't cache selection info for the previous active layer  */
       if (selected_layers)
         gimp_drawable_invalidate_boundary (GIMP_DRAWABLE (selected_layers->data));
 
+      layers3 = g_list_copy (layers2);
       gimp_item_tree_set_selected_items (private->layers, layers2);
 
       /* We cannot edit masks with multiple selected layers. */
-      if (g_list_length (layers2) > 1)
+      if (g_list_length (layers3) > 1)
         {
-          for (iter = layers2; iter; iter = iter->next)
+          for (iter = layers3; iter; iter = iter->next)
             {
               if (gimp_layer_get_mask (iter->data))
                 gimp_layer_set_edit_mask (iter->data, FALSE);
             }
         }
+
+      g_list_free (layers3);
     }
   else
     {
@@ -5333,29 +5388,7 @@ gimp_image_remove_layer (GimpImage *image,
 
   if (push_undo)
     {
-      GimpContainer *filters;
-
-      filters = gimp_drawable_get_filters (GIMP_DRAWABLE (layer));
-
-      if (gimp_container_get_n_children (filters) > 0)
-        {
-          GList *filter_list;
-
-          for (filter_list = GIMP_LIST (filters)->queue->tail; filter_list;
-               filter_list = g_list_previous (filter_list))
-            {
-              if (GIMP_IS_DRAWABLE_FILTER (filter_list->data))
-                {
-                  GimpDrawableFilter *filter = filter_list->data;
-
-                  gimp_image_undo_push_filter_remove (image,
-                                                      _("Remove filter"),
-                                                      GIMP_DRAWABLE (layer),
-                                                      filter);
-                }
-            }
-        }
-
+      gimp_image_rec_filter_remove_undo (image, layer);
       gimp_image_undo_push_layer_remove (image, undo_desc, layer,
                                          gimp_layer_get_parent (layer),
                                          gimp_item_get_index (GIMP_ITEM (layer)),
@@ -5465,6 +5498,7 @@ gimp_image_add_layers (GimpImage   *image,
 
       gimp_image_add_layer (image, GIMP_LAYER (new_item),
                             parent, position, TRUE);
+      gimp_drawable_enable_resize_undo (GIMP_DRAWABLE (new_item));
       position++;
     }
 

app/core/gimplayer.c

@@ -937,16 +937,46 @@ gimp_layer_duplicate (GimpItem *item,
       GimpLayer *layer     = GIMP_LAYER (item);
       GimpLayer *new_layer = GIMP_LAYER (new_item);
 
-      gimp_layer_set_mode            (new_layer,
-                                      gimp_layer_get_mode (layer), FALSE);
-      gimp_layer_set_blend_space     (new_layer,
-                                      gimp_layer_get_blend_space (layer), FALSE);
-      gimp_layer_set_composite_space (new_layer,
-                                      gimp_layer_get_composite_space (layer), FALSE);
-      gimp_layer_set_composite_mode  (new_layer,
-                                      gimp_layer_get_composite_mode (layer), FALSE);
-      gimp_layer_set_opacity         (new_layer,
-                                      gimp_layer_get_opacity (layer), FALSE);
+      /* PASS_THROUGH mode is invalid for regular layers.
+       * We used to change the mode to NORMAL *before* duplicating (see
+       * #793714 on bugzilla) but it would change the image's render.
+       * Instead we first duplicate so that the group's render is used
+       * as-is for the non-group duplicate layer. Then we set NORMAL
+       * mode.
+       */
+      if (gimp_layer_get_mode (layer) == GIMP_LAYER_MODE_PASS_THROUGH &&
+          ! GIMP_IS_GROUP_LAYER (new_item))
+        {
+          GimpLayerColorSpace    blend_space;
+          GimpLayerColorSpace    composite_space;
+          GimpLayerCompositeMode composite_mode;
+
+          /* keep the group's current blend space, composite space, and composite
+           * mode.
+           */
+          blend_space     = gimp_layer_get_blend_space     (layer);
+          composite_space = gimp_layer_get_composite_space (layer);
+          composite_mode  = gimp_layer_get_composite_mode  (layer);
+
+          gimp_layer_set_mode            (new_layer, GIMP_LAYER_MODE_NORMAL, FALSE);
+          gimp_layer_set_blend_space     (new_layer, blend_space,            FALSE);
+          gimp_layer_set_composite_space (new_layer, composite_space,        FALSE);
+          gimp_layer_set_composite_mode  (new_layer, composite_mode,         FALSE);
+          gimp_layer_set_opacity         (new_layer, 1.0,                    FALSE);
+        }
+      else
+        {
+          gimp_layer_set_mode            (new_layer,
+                                          gimp_layer_get_mode (layer), FALSE);
+          gimp_layer_set_blend_space     (new_layer,
+                                          gimp_layer_get_blend_space (layer), FALSE);
+          gimp_layer_set_composite_space (new_layer,
+                                          gimp_layer_get_composite_space (layer), FALSE);
+          gimp_layer_set_composite_mode  (new_layer,
+                                          gimp_layer_get_composite_mode (layer), FALSE);
+          gimp_layer_set_opacity         (new_layer,
+                                          gimp_layer_get_opacity (layer), FALSE);
+        }
 
       if (gimp_layer_can_lock_alpha (new_layer))
         gimp_layer_set_lock_alpha (new_layer,

app/core/gimpparamspecs-desc.c

@@ -48,12 +48,14 @@ gimp_param_spec_boolean_desc (GParamSpec *pspec)
 static gchar *
 gimp_param_spec_unit_desc (GParamSpec *pspec)
 {
-  GimpParamSpecUnit *uspec = GIMP_PARAM_SPEC_UNIT (pspec);
+  GObject *default_value;
+
+  default_value = gimp_param_spec_object_get_default (pspec);
 
   return g_strdup_printf ("<i>(default %s%s%s)</i>",
-                          gimp_unit_get_abbreviation (uspec->default_value),
-                          uspec->allow_pixel ? ", pixel allowed": "",
-                          uspec->allow_percent ? ", percent allowed": "");
+                          gimp_unit_get_abbreviation (GIMP_UNIT (default_value)),
+                          gimp_param_spec_unit_pixel_allowed (pspec) ? ", pixel allowed": "",
+                          gimp_param_spec_unit_percent_allowed (pspec) ? ", percent allowed": "");
 }
 
 static gchar *

app/core/gimppatternclipboard.c

@@ -29,9 +29,11 @@
 
 #include "gimp.h"
 #include "gimpbuffer.h"
+#include "gimpchannel.h"
 #include "gimppatternclipboard.h"
 #include "gimpimage.h"
 #include "gimppickable.h"
+#include "gimpselection.h"
 #include "gimptempbuf.h"
 
 #include "gimp-intl.h"
@@ -175,7 +177,8 @@ gimp_pattern_clipboard_changed (Gimp        *gimp,
                                 GimpPattern *pattern)
 {
   GimpObject *paste;
-  GeglBuffer *buffer = NULL;
+  GeglBuffer *buffer       = NULL;
+  gboolean    unref_buffer = FALSE;
 
   g_clear_pointer (&pattern->mask, gimp_temp_buf_unref);
 
@@ -183,8 +186,38 @@ gimp_pattern_clipboard_changed (Gimp        *gimp,
 
   if (GIMP_IS_IMAGE (paste))
     {
+      GimpContext *context = gimp_get_user_context (gimp);
+
       gimp_pickable_flush (GIMP_PICKABLE (paste));
-      buffer = gimp_pickable_get_buffer (GIMP_PICKABLE (paste));
+      if (context)
+        {
+          GimpChannel *mask = gimp_image_get_mask (GIMP_IMAGE (paste));
+
+          if (! gimp_channel_is_empty (mask))
+            {
+              GList *pickables;
+              gint   offset_x;
+              gint   offset_y;
+
+              pickables = g_list_prepend (NULL, GIMP_IMAGE (paste));
+              buffer = gimp_selection_extract (GIMP_SELECTION (mask),
+                                               pickables, context,
+                                               FALSE, FALSE, FALSE,
+                                               &offset_x, &offset_y,
+                                               NULL);
+              g_list_free (pickables);
+
+              unref_buffer = TRUE;
+            }
+          else
+            {
+              buffer = gimp_pickable_get_buffer (GIMP_PICKABLE (paste));
+            }
+        }
+      else
+        {
+          buffer = gimp_pickable_get_buffer (GIMP_PICKABLE (paste));
+        }
     }
   else if (GIMP_IS_BUFFER (paste))
     {
@@ -204,6 +237,9 @@ gimp_pattern_clipboard_changed (Gimp        *gimp,
                        NULL,
                        gimp_temp_buf_get_data (pattern->mask),
                        GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
+
+      if (unref_buffer)
+        g_object_unref (buffer);
     }
   else
     {

app/core/gimppickable-contiguous-region.cc

@@ -144,7 +144,7 @@ gimp_pickable_contiguous_region_by_seed (GimpPickable        *pickable,
   g_return_val_if_fail (GIMP_IS_PICKABLE (pickable), NULL);
 
   gimp_pickable_flush (pickable);
-  src_buffer = gimp_pickable_get_buffer (pickable);
+  src_buffer = gimp_pickable_get_buffer_with_effects (pickable);
 
   format = choose_format (src_buffer, select_criterion,
                           &n_components, &has_alpha);
@@ -222,7 +222,7 @@ gimp_pickable_contiguous_region_by_color (GimpPickable        *pickable,
 
   gimp_pickable_flush (pickable);
 
-  src_buffer = gimp_pickable_get_buffer (pickable);
+  src_buffer = gimp_pickable_get_buffer_with_effects (pickable);
 
   format = choose_format (src_buffer, select_criterion,
                           &n_components, &has_alpha);

app/core/gimppickable.c

@@ -314,9 +314,6 @@ gimp_pickable_pick_color (GimpPickable *pickable,
     {
       gint radius = floor (average_radius);
 
-      format = babl_format_with_space ("RaGaBaA double",
-                                       babl_format_get_space (format));
-
       gimp_pickable_get_pixel_average (pickable,
                                        GEGL_RECTANGLE (x - radius,
                                                        y - radius,

app/core/gimpprojection.c

@@ -124,11 +124,8 @@ static void        gimp_projection_add_update_area       (GimpProjection  *proj,
                                                           gint             y,
                                                           gint             w,
                                                           gint             h);
-static void        gimp_projection_flush_whenever        (GimpProjection  *proj,
-                                                          gboolean         now,
-                                                          gboolean         direct);
 static void        gimp_projection_update_priority_rect  (GimpProjection  *proj);
-static void        gimp_projection_chunk_render_start    (GimpProjection  *proj);
+static gboolean    gimp_projection_chunk_render_start    (GWeakRef        *proj_ref);
 static void        gimp_projection_chunk_render_stop     (GimpProjection  *proj,
                                                           gboolean         merge);
 static gboolean    gimp_projection_chunk_render_callback (GimpProjection  *proj);
@@ -493,23 +490,70 @@ gimp_projection_stop_rendering (GimpProjection *proj)
   gimp_projection_chunk_render_stop (proj, TRUE);
 }
 
+/**
+ * gimp_projection_flush:
+ * @proj:
+ *
+ * This requests to render the projection. This function is thread-safe
+ * and can be called in any thread.
+ *
+ * The actual projection painting will happen in the main thread.
+ */
 void
 gimp_projection_flush (GimpProjection *proj)
 {
+  GWeakRef *proj_ref = g_new (GWeakRef, 1);;
+
   g_return_if_fail (GIMP_IS_PROJECTION (proj));
 
-  /* Construct in chunks */
-  gimp_projection_flush_whenever (proj, FALSE, FALSE);
+  g_weak_ref_init (proj_ref, proj);
+  /* Construct in chunks - asynchronously in the main thread */
+  g_idle_add_full (G_PRIORITY_HIGH_IDLE,
+                   (GSourceFunc) gimp_projection_chunk_render_start,
+                   proj_ref, NULL);
 }
 
+/**
+ * gimp_projection_flush_now:
+ * @proj:
+ * @direct:
+ *
+ * This renders the projection immediately. You can only call this from
+ * the main thread.
+ */
 void
 gimp_projection_flush_now (GimpProjection *proj,
                            gboolean        direct)
 {
   g_return_if_fail (GIMP_IS_PROJECTION (proj));
 
-  /* Construct NOW */
-  gimp_projection_flush_whenever (proj, TRUE, direct);
+  /* Construct NOW - synchronously */
+  if (proj->priv->update_region)
+    {
+      gint n_rects = cairo_region_num_rectangles (proj->priv->update_region);
+      gint i;
+
+      /* Make sure we have a buffer */
+      gimp_projection_allocate_buffer (proj);
+
+      for (i = 0; i < n_rects; i++)
+        {
+          cairo_rectangle_int_t rect;
+
+          cairo_region_get_rectangle (proj->priv->update_region,
+                                      i, &rect);
+
+          gimp_projection_paint_area (proj,
+                                      direct,
+                                      rect.x,
+                                      rect.y,
+                                      rect.width,
+                                      rect.height);
+        }
+
+      /*  Free the update region  */
+      g_clear_pointer (&proj->priv->update_region, cairo_region_destroy);
+    }
 }
 
 void
@@ -611,56 +655,6 @@ gimp_projection_add_update_area (GimpProjection *proj,
     }
 }
 
-static void
-gimp_projection_flush_whenever (GimpProjection *proj,
-                                gboolean        now,
-                                gboolean        direct)
-{
-  if (proj->priv->update_region)
-    {
-      /* Make sure we have a buffer */
-      gimp_projection_allocate_buffer (proj);
-
-      if (now)  /* Synchronous */
-        {
-          gint n_rects = cairo_region_num_rectangles (proj->priv->update_region);
-          gint i;
-
-          for (i = 0; i < n_rects; i++)
-            {
-              cairo_rectangle_int_t rect;
-
-              cairo_region_get_rectangle (proj->priv->update_region,
-                                          i, &rect);
-
-              gimp_projection_paint_area (proj,
-                                          direct,
-                                          rect.x,
-                                          rect.y,
-                                          rect.width,
-                                          rect.height);
-            }
-
-          /*  Free the update region  */
-          g_clear_pointer (&proj->priv->update_region, cairo_region_destroy);
-        }
-      else  /* Asynchronous */
-        {
-          /*  Consumes the update region  */
-          gimp_projection_chunk_render_start (proj);
-        }
-    }
-  else if (! now && ! proj->priv->iter && proj->priv->invalidate_preview)
-    {
-      /* invalidate the preview here since it is constructed from
-       * the projection
-       */
-      proj->priv->invalidate_preview = FALSE;
-
-      gimp_projectable_invalidate_preview (proj->priv->projectable);
-    }
-}
-
 static void
 gimp_projection_update_priority_rect (GimpProjection *proj)
 {
@@ -688,66 +682,93 @@ gimp_projection_update_priority_rect (GimpProjection *proj)
     }
 }
 
-static void
-gimp_projection_chunk_render_start (GimpProjection *proj)
+static gboolean
+gimp_projection_chunk_render_start (GWeakRef *proj_ref)
 {
-  cairo_region_t *region             = proj->priv->update_region;
-  gboolean        invalidate_preview = FALSE;
+  GimpProjection *proj;
 
-  if (proj->priv->iter)
+  proj = g_weak_ref_get (proj_ref);
+  g_weak_ref_clear (proj_ref);
+  g_free (proj_ref);
+
+  if (proj == NULL)
+    return G_SOURCE_REMOVE;
+
+  if (proj->priv->update_region)
     {
-      region = gimp_chunk_iterator_stop (proj->priv->iter, FALSE);
+      cairo_region_t *region             = proj->priv->update_region;
+      gboolean        invalidate_preview = FALSE;
 
-      proj->priv->iter = NULL;
+      /* Make sure we have a buffer */
+      gimp_projection_allocate_buffer (proj);
 
-      if (cairo_region_is_empty (region))
-        invalidate_preview = proj->priv->invalidate_preview;
-
-      if (proj->priv->update_region)
+      if (proj->priv->iter)
         {
-          cairo_region_union (region, proj->priv->update_region);
+          region = gimp_chunk_iterator_stop (proj->priv->iter, FALSE);
 
-          cairo_region_destroy (proj->priv->update_region);
+          proj->priv->iter = NULL;
+
+          if (cairo_region_is_empty (region))
+            invalidate_preview = proj->priv->invalidate_preview;
+
+          if (proj->priv->update_region)
+            {
+              cairo_region_union (region, proj->priv->update_region);
+
+              cairo_region_destroy (proj->priv->update_region);
+            }
+        }
+
+      proj->priv->update_region = NULL;
+
+      if (region && ! cairo_region_is_empty (region))
+        {
+          proj->priv->iter = gimp_chunk_iterator_new (region);
+
+          gimp_projection_update_priority_rect (proj);
+
+          if (! proj->priv->idle_id)
+            {
+              proj->priv->idle_id = g_idle_add_full (GIMP_PRIORITY_PROJECTION_IDLE + proj->priv->priority,
+                                                     (GSourceFunc) gimp_projection_chunk_render_callback,
+                                                     proj, NULL);
+            }
+        }
+      else
+        {
+          if (region)
+            cairo_region_destroy (region);
+
+          if (proj->priv->idle_id)
+            {
+              g_source_remove (proj->priv->idle_id);
+              proj->priv->idle_id = 0;
+            }
+
+          if (invalidate_preview)
+            {
+              /* invalidate the preview here since it is constructed from
+               * the projection
+               */
+              proj->priv->invalidate_preview = FALSE;
+
+              gimp_projectable_invalidate_preview (proj->priv->projectable);
+            }
         }
     }
-
-  proj->priv->update_region = NULL;
-
-  if (region && ! cairo_region_is_empty (region))
+  else if (! proj->priv->iter && proj->priv->invalidate_preview)
     {
-      proj->priv->iter = gimp_chunk_iterator_new (region);
+      /* invalidate the preview here since it is constructed from
+       * the projection
+       */
+      proj->priv->invalidate_preview = FALSE;
 
-      gimp_projection_update_priority_rect (proj);
-
-      if (! proj->priv->idle_id)
-        {
-          proj->priv->idle_id = g_idle_add_full (
-            GIMP_PRIORITY_PROJECTION_IDLE + proj->priv->priority,
-            (GSourceFunc) gimp_projection_chunk_render_callback,
-            proj, NULL);
-        }
+      gimp_projectable_invalidate_preview (proj->priv->projectable);
     }
-  else
-    {
-      if (region)
-        cairo_region_destroy (region);
 
-      if (proj->priv->idle_id)
-        {
-          g_source_remove (proj->priv->idle_id);
-          proj->priv->idle_id = 0;
-        }
+  g_object_unref (proj);
 
-      if (invalidate_preview)
-        {
-          /* invalidate the preview here since it is constructed from
-           * the projection
-           */
-          proj->priv->invalidate_preview = FALSE;
-
-          gimp_projectable_invalidate_preview (proj->priv->projectable);
-        }
-    }
+  return G_SOURCE_REMOVE;
 }
 
 static void

app/dialogs/about-dialog.c

@@ -76,6 +76,9 @@ typedef struct
   gboolean        visible;
 } GimpAboutDialog;
 
+static void        about_dialog_response      (GtkDialog       *dialog,
+                                               gint             response_id,
+                                               gpointer         user_data);
 #ifdef G_OS_WIN32
 static void        about_dialog_realize       (GtkWidget       *widget,
                                                GimpAboutDialog *dialog);
@@ -95,10 +98,10 @@ static gboolean    about_dialog_anim_draw     (GtkWidget       *widget,
 static void        about_dialog_reshuffle     (GimpAboutDialog *dialog);
 static gboolean    about_dialog_timer         (gpointer         data);
 
-#ifdef GIMP_UNSTABLE
+#ifndef GIMP_RELEASE
 static void        about_dialog_add_unstable_message
                                               (GtkWidget       *vbox);
-#endif /* GIMP_UNSTABLE */
+#endif /* ! GIMP_RELEASE */
 
 static void        about_dialog_last_release_changed
                                               (GimpCoreConfig   *config,
@@ -180,7 +183,7 @@ about_dialog_create (Gimp           *gimp,
       g_set_weak_pointer (&dialog.dialog, widget);
 
       g_signal_connect (widget, "response",
-                        G_CALLBACK (gtk_widget_destroy),
+                        G_CALLBACK (about_dialog_response),
                         NULL);
 #ifdef G_OS_WIN32
       g_signal_connect (widget, "realize",
@@ -202,9 +205,9 @@ about_dialog_create (Gimp           *gimp,
         {
           if (dialog.use_animation)
             about_dialog_add_animation (children->data, &dialog);
-#ifdef GIMP_UNSTABLE
+#ifndef GIMP_RELEASE
           about_dialog_add_unstable_message (children->data);
-#endif /* GIMP_UNSTABLE */
+#endif /* ! GIMP_RELEASE */
 #ifdef CHECK_UPDATE
           if (gimp_version_check_update ())
             about_dialog_add_update (&dialog, config);
@@ -232,6 +235,17 @@ about_dialog_create (Gimp           *gimp,
   return dialog.dialog;
 }
 
+static void
+about_dialog_response (GtkDialog *dialog,
+                       gint       response_id,
+                       gpointer   user_data)
+{
+  if (response_id == GTK_RESPONSE_HELP)
+    gimp_standard_help_func (GIMP_HELP_ABOUT_DIALOG, NULL);
+  else
+    gtk_widget_destroy (GTK_WIDGET (dialog));
+}
+
 #ifdef G_OS_WIN32
 static void
 about_dialog_realize (GtkWidget *widget,
@@ -794,7 +808,7 @@ about_dialog_timer (gpointer data)
   return G_SOURCE_CONTINUE;
 }
 
-#ifdef GIMP_UNSTABLE
+#ifndef GIMP_RELEASE
 
 static void
 about_dialog_add_unstable_message (GtkWidget *vbox)
@@ -802,7 +816,7 @@ about_dialog_add_unstable_message (GtkWidget *vbox)
   GtkWidget *label;
   gchar     *text;
 
-  text = g_strdup_printf (_("This is an unstable development release\n"
+  text = g_strdup_printf (_("This is a development build\n"
                             "commit %s"), GIMP_GIT_VERSION_ABBREV);
   label = gtk_label_new (text);
   g_free (text);
@@ -817,7 +831,7 @@ about_dialog_add_unstable_message (GtkWidget *vbox)
   gtk_widget_show (label);
 }
 
-#endif /* GIMP_UNSTABLE */
+#endif /* ! GIMP_RELEASE */
 
 static void
 about_dialog_last_release_changed (GimpCoreConfig   *config,

app/dialogs/file-open-dialog.c

@@ -131,6 +131,14 @@ file_open_dialog_response (GtkWidget *dialog,
   if (file_dialog->image)
     g_object_ref (file_dialog->image);
 
+  /* If we open multiple files as layers, compress the undos */
+  if (file_dialog->image          &&
+      open_dialog->open_as_layers &&
+      g_slist_length (files) > 1)
+    gimp_image_undo_group_start (file_dialog->image,
+                                 GIMP_UNDO_GROUP_LAYER_ADD,
+                                 _("Open layers"));
+
   for (list = files; list; list = g_slist_next (list))
     {
       GFile *file = list->data;
@@ -150,6 +158,12 @@ file_open_dialog_response (GtkWidget *dialog,
               if (file_dialog->image)
                 {
                   g_object_ref (file_dialog->image);
+
+                  if (g_slist_length (files) > 1)
+                    gimp_image_undo_group_start (file_dialog->image,
+                                                 GIMP_UNDO_GROUP_LAYER_ADD,
+                                                 _("Open layers"));
+
                   success = TRUE;
                 }
             }
@@ -181,6 +195,11 @@ file_open_dialog_response (GtkWidget *dialog,
         break;
     }
 
+  if (file_dialog->image          &&
+      open_dialog->open_as_layers &&
+      g_slist_length (files) > 1)
+    gimp_image_undo_group_end (file_dialog->image);
+
   if (success)
     {
       if (file_dialog->image)

app/dialogs/welcome-dialog.c

@@ -285,17 +285,20 @@ welcome_dialog_new (Gimp       *gimp,
   if (! show_welcome_page)
     gtk_stack_set_visible_child_name (GTK_STACK (stack), "gimp-welcome-create");
 
-  main_vbox = gimp_prefs_box_add_page (GIMP_PREFS_BOX (prefs_box),
-                                       "gimp-wilber",
-                                       _("Release Notes"),
-                                       _("Release Notes"),
-                                       "gimp-welcome-release_notes",
-                                       NULL,
-                                       &top_iter);
-  gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
+  if (gimp_welcome_dialog_n_items > 0)
+    {
+      main_vbox = gimp_prefs_box_add_page (GIMP_PREFS_BOX (prefs_box),
+                                           "gimp-wilber",
+                                           _("Release Notes"),
+                                           _("Release Notes"),
+                                           "gimp-welcome-release_notes",
+                                           NULL,
+                                           &top_iter);
+      gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
 
-  welcome_dialog_create_release_page (gimp, dialog, main_vbox);
-  gtk_widget_set_visible (main_vbox, TRUE);
+      welcome_dialog_create_release_page (gimp, dialog, main_vbox);
+      gtk_widget_set_visible (main_vbox, TRUE);
+    }
 
   return dialog;
 }
@@ -421,12 +424,11 @@ welcome_dialog_create_welcome_page (Gimp      *gimp,
 
   /* Translators: the %s string will be the version, e.g. "3.0". */
   tmp = g_strdup_printf (_("You installed GIMP %s!"), GIMP_VERSION);
-  markup = g_strdup_printf ("<big>%s</big>", tmp);
-  g_free (tmp);
   widget = gtk_label_new (NULL);
-  gtk_label_set_markup (GTK_LABEL (widget), markup);
-  g_free (markup);
-  gtk_label_set_selectable (GTK_LABEL (widget), TRUE);
+  /* XXX For GTK4, we may just replace with gtk_widget_add_css_class() AFAICS. */
+  gtk_style_context_add_class (gtk_widget_get_style_context (widget), "title-3");
+  gtk_label_set_text (GTK_LABEL (widget), tmp);
+  g_free (tmp);
   gtk_label_set_justify (GTK_LABEL (widget), GTK_JUSTIFY_CENTER);
   gtk_label_set_line_wrap (GTK_LABEL (widget), FALSE);
   gtk_widget_set_margin_bottom (widget, 10);

app/display/gimpcanvas-style.c

@@ -232,7 +232,7 @@ gimp_canvas_set_guide_style (GtkWidget      *canvas,
                              gdouble         offset_y)
 {
   const Babl      *render_space;
-  GimpColorConfig *config;
+  GimpColorConfig *config = NULL;
   cairo_pattern_t *pattern;
   GeglColor       *normal_fg;
   GeglColor       *normal_bg;
@@ -284,7 +284,8 @@ gimp_canvas_set_guide_style (GtkWidget      *canvas,
 
   cairo_set_line_width (cr, line_width);
 
-  config = GIMP_CORE_CONFIG (GIMP_CANVAS (canvas)->config)->color_management;
+  if (GIMP_IS_CANVAS (canvas))
+    config = GIMP_CORE_CONFIG (GIMP_CANVAS (canvas)->config)->color_management;
   render_space = gimp_widget_get_render_space (canvas, config);
   if (active)
     pattern = gimp_cairo_pattern_create_stipple (active_fg, active_bg, 0,
@@ -324,7 +325,7 @@ gimp_canvas_set_grid_style (GtkWidget *canvas,
                             gdouble    offset_y)
 {
   const Babl      *render_space;
-  GimpColorConfig *config;
+  GimpColorConfig *config = NULL;
   GeglColor       *fg;
   GeglColor       *bg;
 
@@ -336,7 +337,8 @@ gimp_canvas_set_grid_style (GtkWidget *canvas,
 
   fg = gimp_grid_get_fgcolor (grid);
 
-  config = GIMP_CORE_CONFIG (GIMP_CANVAS (canvas)->config)->color_management;
+  if (GIMP_IS_CANVAS (canvas))
+    config = GIMP_CORE_CONFIG (GIMP_CANVAS (canvas)->config)->color_management;
   render_space = gimp_widget_get_render_space (canvas, config);
   switch (gimp_grid_get_style (grid))
     {
@@ -403,7 +405,7 @@ gimp_canvas_set_layer_style (GtkWidget *canvas,
                              gdouble    offset_y)
 {
   const Babl      *render_space;
-  GimpColorConfig *config;
+  GimpColorConfig *config = NULL;
   cairo_pattern_t *pattern;
 
   g_return_if_fail (GTK_IS_WIDGET (canvas));
@@ -413,7 +415,8 @@ gimp_canvas_set_layer_style (GtkWidget *canvas,
   cairo_set_line_width (cr, 1.0);
   cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
 
-  config = GIMP_CORE_CONFIG (GIMP_CANVAS (canvas)->config)->color_management;
+  if (GIMP_IS_CANVAS (canvas))
+    config = GIMP_CORE_CONFIG (GIMP_CANVAS (canvas)->config)->color_management;
   render_space = gimp_widget_get_render_space (canvas, config);
   if (gimp_layer_get_mask (layer) &&
       gimp_layer_get_edit_mask (layer))
@@ -445,7 +448,7 @@ gimp_canvas_set_canvas_style (GtkWidget *canvas,
                               gdouble    offset_y)
 {
   const Babl      *render_space;
-  GimpColorConfig *config;
+  GimpColorConfig *config = NULL;
   cairo_pattern_t *pattern;
 
   g_return_if_fail (GTK_IS_WIDGET (canvas));
@@ -454,7 +457,8 @@ gimp_canvas_set_canvas_style (GtkWidget *canvas,
   cairo_set_line_width (cr, 1.0);
   cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
 
-  config = GIMP_CORE_CONFIG (GIMP_CANVAS (canvas)->config)->color_management;
+  if (GIMP_IS_CANVAS (canvas))
+    config = GIMP_CORE_CONFIG (GIMP_CANVAS (canvas)->config)->color_management;
   render_space = gimp_widget_get_render_space (canvas, config);
   pattern = gimp_cairo_pattern_create_stipple (canvas_fg, canvas_bg, 0,
                                                offset_x, offset_y, render_space);
@@ -470,7 +474,7 @@ gimp_canvas_set_selection_out_style (GtkWidget *canvas,
                                      gdouble    offset_y)
 {
   const Babl      *render_space;
-  GimpColorConfig *config;
+  GimpColorConfig *config = NULL;
   cairo_pattern_t *pattern;
 
   g_return_if_fail (GTK_IS_WIDGET (canvas));
@@ -479,7 +483,8 @@ gimp_canvas_set_selection_out_style (GtkWidget *canvas,
   cairo_set_line_width (cr, 1.0);
   cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
 
-  config = GIMP_CORE_CONFIG (GIMP_CANVAS (canvas)->config)->color_management;
+  if (GIMP_IS_CANVAS (canvas))
+    config = GIMP_CORE_CONFIG (GIMP_CANVAS (canvas)->config)->color_management;
   render_space = gimp_widget_get_render_space (canvas, config);
   pattern = gimp_cairo_pattern_create_stipple (selection_out_fg, selection_out_bg, 0,
                                                offset_x, offset_y, render_space);
@@ -495,7 +500,7 @@ gimp_canvas_set_selection_in_style (GtkWidget *canvas,
                                     gdouble    offset_y)
 {
   const Babl      *render_space;
-  GimpColorConfig *config;
+  GimpColorConfig *config = NULL;
   cairo_pattern_t *pattern;
 
   g_return_if_fail (GTK_IS_WIDGET (canvas));
@@ -504,7 +509,8 @@ gimp_canvas_set_selection_in_style (GtkWidget *canvas,
   cairo_set_line_width (cr, 1.0);
   cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
 
-  config = GIMP_CORE_CONFIG (GIMP_CANVAS (canvas)->config)->color_management;
+  if (GIMP_IS_CANVAS (canvas))
+    config = GIMP_CORE_CONFIG (GIMP_CANVAS (canvas)->config)->color_management;
   render_space = gimp_widget_get_render_space (canvas, config);
   pattern = gimp_cairo_pattern_create_stipple (selection_in_fg, selection_in_bg, index,
                                                offset_x, offset_y, render_space);

app/display/gimpdisplayshell-dnd.c

@@ -292,6 +292,7 @@ gimp_display_shell_drop_drawable (GtkWidget    *widget,
 
       gimp_image_add_layer (image, new_layer,
                             GIMP_IMAGE_ACTIVE_PARENT, -1, TRUE);
+      gimp_drawable_enable_resize_undo (GIMP_DRAWABLE (new_layer));
 
       gimp_image_undo_group_end (image);
 

app/display/gimpdisplayshell-scale.c

@@ -933,7 +933,7 @@ gimp_display_shell_set_initial_scale (GimpDisplayShell *shell,
 
   image = gimp_display_get_image (shell->display);
 
-  gdk_monitor_get_workarea (shell->initial_monitor, &workarea);
+  gdk_monitor_get_workarea (gimp_widget_get_monitor (GTK_WIDGET (shell)), &workarea);
 
   image_width  = gimp_image_get_width  (image);
   image_height = gimp_image_get_height (image);

app/display/gimpdisplayshell-tool-events.c

@@ -859,7 +859,8 @@ gimp_display_shell_canvas_tool_events (GtkWidget        *canvas,
         update_sw_cursor = TRUE;
 
         if (shell->mod_action != GIMP_MODIFIER_ACTION_NONE ||
-            shell->space_release_pending)
+            (shell->space_release_pending &&
+             shell->display->config->space_bar_action == GIMP_SPACE_BAR_ACTION_PAN))
           {
             gimp_display_shell_handle_scrolling (shell,
                                                  state, mevent->x, mevent->y);

app/display/gimpdisplayshell.c

@@ -118,6 +118,11 @@ enum
   LAST_SIGNAL
 };
 
+struct _GimpDisplayShellPrivate
+{
+  GdkMonitor *initial_monitor;
+};
+
 
 typedef struct _GimpDisplayShellOverlay GimpDisplayShellOverlay;
 
@@ -194,6 +199,7 @@ static gboolean gimp_display_shell_draw            (GimpDisplayShell *shell,
 
 G_DEFINE_TYPE_WITH_CODE (GimpDisplayShell, gimp_display_shell,
                          GTK_TYPE_EVENT_BOX,
+                         G_ADD_PRIVATE (GimpDisplayShell)
                          G_IMPLEMENT_INTERFACE (GIMP_TYPE_PROGRESS,
                                                 gimp_display_shell_progress_iface_init)
                          G_IMPLEMENT_INTERFACE (GIMP_TYPE_COLOR_MANAGED,
@@ -336,6 +342,9 @@ gimp_display_shell_init (GimpDisplayShell *shell)
 {
   const gchar *env;
 
+  shell->priv = gimp_display_shell_get_instance_private (shell);
+  shell->priv->initial_monitor = NULL;
+
   shell->options            = g_object_new (GIMP_TYPE_DISPLAY_OPTIONS, NULL);
   shell->fullscreen_options = g_object_new (GIMP_TYPE_DISPLAY_OPTIONS_FULLSCREEN, NULL);
   shell->no_image_options   = g_object_new (GIMP_TYPE_DISPLAY_OPTIONS_NO_IMAGE, NULL);
@@ -492,7 +501,7 @@ gimp_display_shell_constructed (GObject *object)
 
   if (config->monitor_res_from_gdk)
     {
-      gimp_get_monitor_resolution (shell->initial_monitor,
+      gimp_get_monitor_resolution (shell->priv->initial_monitor,
                                    &shell->monitor_xres, &shell->monitor_yres);
     }
   else
@@ -817,6 +826,9 @@ gimp_display_shell_constructed (GObject *object)
   gimp_display_shell_scale_update (shell);
 
   gimp_display_shell_set_show_all (shell, config->default_show_all);
+
+  /* This was only useful during construction and should not be further used. */
+  shell->priv->initial_monitor = NULL;
 }
 
 static void
@@ -926,7 +938,7 @@ gimp_display_shell_set_property (GObject      *object,
       shell->popup_manager = g_value_get_object (value);
       break;
     case PROP_INITIAL_MONITOR:
-      shell->initial_monitor = g_value_get_object (value);
+      shell->priv->initial_monitor = g_value_get_object (value);
       break;
     case PROP_DISPLAY:
       shell->display = g_value_get_object (value);
@@ -966,7 +978,7 @@ gimp_display_shell_get_property (GObject    *object,
       g_value_set_object (value, shell->popup_manager);
       break;
     case PROP_INITIAL_MONITOR:
-      g_value_set_object (value, shell->initial_monitor);
+      g_value_set_object (value, shell->priv->initial_monitor);
       break;
     case PROP_DISPLAY:
       g_value_set_object (value, shell->display);

app/display/gimpdisplayshell.h

@@ -43,7 +43,8 @@
 #define GIMP_DISPLAY_SHELL_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_DISPLAY_SHELL, GimpDisplayShellClass))
 
 
-typedef struct _GimpDisplayShellClass  GimpDisplayShellClass;
+typedef struct _GimpDisplayShellClass   GimpDisplayShellClass;
+typedef struct _GimpDisplayShellPrivate GimpDisplayShellPrivate;
 
 struct _GimpDisplayShell
 {
@@ -54,7 +55,6 @@ struct _GimpDisplayShell
   GBytes            *window_handle;
 
   GimpUIManager     *popup_manager;
-  GdkMonitor        *initial_monitor;
 
   GimpDisplayOptions *options;
   GimpDisplayOptions *fullscreen_options;
@@ -255,6 +255,8 @@ struct _GimpDisplayShell
   GimpLayer         *near_layer_vertical2;
 
   gboolean           drawn;
+
+  GimpDisplayShellPrivate *priv;
 };
 
 struct _GimpDisplayShellClass

app/display/gimpimagewindow.c

@@ -569,6 +569,9 @@ gimp_image_window_constructed (GObject *object)
   gimp_container_foreach (GIMP_CONTAINER (device_manager),
                           (GFunc) gimp_image_window_init_pad_foreach,
                           window);
+
+  /* This was only useful during construction and should not be further used. */
+  private->initial_monitor = NULL;
 }
 
 static void

app/display/gimpstatusbar.c

@@ -540,10 +540,10 @@ gimp_statusbar_init (GimpStatusbar *statusbar)
                     statusbar);
 
   combo_store =
-    gimp_int_store_new ("Perceptual",            GIMP_COLOR_RENDERING_INTENT_PERCEPTUAL,
-                        "Relative Colorimetric", GIMP_COLOR_RENDERING_INTENT_RELATIVE_COLORIMETRIC,
-                        "Saturation",            GIMP_COLOR_RENDERING_INTENT_SATURATION,
-                        "Absolute Colorimetric", GIMP_COLOR_RENDERING_INTENT_ABSOLUTE_COLORIMETRIC,
+    gimp_int_store_new (_("Perceptual"),            GIMP_COLOR_RENDERING_INTENT_PERCEPTUAL,
+                        _("Relative Colorimetric"), GIMP_COLOR_RENDERING_INTENT_RELATIVE_COLORIMETRIC,
+                        _("Saturation"),            GIMP_COLOR_RENDERING_INTENT_SATURATION,
+                        _("Absolute Colorimetric"), GIMP_COLOR_RENDERING_INTENT_ABSOLUTE_COLORIMETRIC,
                         NULL);
   statusbar->rendering_intent_combo = g_object_new (GIMP_TYPE_INT_COMBO_BOX,
                             "model", combo_store,

app/display/gimptoolpath.c

@@ -1400,16 +1400,28 @@ gimp_tool_path_get_function (GimpToolPath     *path,
         {
           if (anchor->type == GIMP_ANCHOR_ANCHOR)
             {
-              if (state & TOGGLE_MASK)
+              if (! (state & TOGGLE_MASK)                         &&
+                  private->sel_anchor                             &&
+                  private->sel_anchor != anchor                   &&
+                  gimp_stroke_is_extendable (private->sel_stroke,
+                                             private->sel_anchor) &&
+                  gimp_stroke_is_extendable (stroke, anchor))
                 {
-                  function = VECTORS_MOVE_ANCHORSET;
+                  function = VECTORS_CONNECT_STROKES;
                 }
               else
                 {
-                  if (private->sel_count >= 2 && anchor->selected)
-                    function = VECTORS_MOVE_ANCHORSET;
+                  if (state & TOGGLE_MASK)
+                    {
+                      function = VECTORS_MOVE_ANCHORSET;
+                    }
                   else
-                    function = VECTORS_MOVE_ANCHOR;
+                    {
+                      if (private->sel_count >= 2 && anchor->selected)
+                        function = VECTORS_MOVE_ANCHORSET;
+                      else
+                        function = VECTORS_MOVE_ANCHOR;
+                    }
                 }
             }
           else

app/errors.c

@@ -328,9 +328,17 @@ gimp_eek (const gchar *reason,
            * takes precedence over the command line argument.
            */
 #ifdef G_OS_WIN32
-          const gchar *gimpdebug = "gimp-debug-tool-" GIMP_TOOL_VERSION ".exe";
+#ifdef ENABLE_RELOCATABLE_RESOURCES
+          const gchar *gimpdebug = g_build_filename (gimp_installation_directory (), "bin",
+                                                     "gimp-debug-tool-" GIMP_TOOL_VERSION ".exe", NULL);
+#else
+          const gchar *gimpdebug = BINDIR "/gimp-debug-tool-" GIMP_TOOL_VERSION ".exe";
+#endif
 #elif defined (PLATFORM_OSX)
           const gchar *gimpdebug = "gimp-debug-tool-" GIMP_TOOL_VERSION;
+#elif !defined (G_OS_WIN32) && !defined (PLATFORM_OSX) && defined ENABLE_RELOCATABLE_RESOURCES
+          const gchar *gimpdebug = g_build_filename (gimp_installation_directory (),
+                                                     "libexec", "gimp-debug-tool-" GIMP_TOOL_VERSION, NULL);
 #else
           const gchar *gimpdebug = LIBEXECDIR "/gimp-debug-tool-" GIMP_TOOL_VERSION;
 #endif

app/file/file-open.c

@@ -121,8 +121,7 @@ file_open_image (Gimp                *gimp,
     }
 
   /* FIXME enable these tests for remote files again, needs testing */
-  if (g_file_is_native (file) &&
-      g_file_query_exists (file, NULL))
+  if (g_file_is_native (file))
     {
       GFileInfo *info;
 
@@ -131,27 +130,35 @@ file_open_image (Gimp                *gimp,
                                 G_FILE_ATTRIBUTE_ACCESS_CAN_READ,
                                 G_FILE_QUERY_INFO_NONE,
                                 NULL, error);
-      if (! info)
-        return NULL;
 
-      if (g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_STANDARD_TYPE) != G_FILE_TYPE_REGULAR)
+      if (info != NULL)
         {
-          g_set_error_literal (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
-                               _("Not a regular file"));
+          if (g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_STANDARD_TYPE) != G_FILE_TYPE_REGULAR)
+            {
+              g_set_error_literal (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
+                                   _("Not a regular file"));
+              g_object_unref (info);
+              return NULL;
+            }
+
+          if (! g_file_info_get_attribute_boolean (info,
+                                                   G_FILE_ATTRIBUTE_ACCESS_CAN_READ))
+            {
+              g_set_error_literal (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
+                                   _("Permission denied"));
+              g_object_unref (info);
+              return NULL;
+            }
+
           g_object_unref (info);
+        }
+      else
+        {
+          /* File likely does not exists. error will already have a more
+           * accurate reason.
+           */
           return NULL;
         }
-
-      if (! g_file_info_get_attribute_boolean (info,
-                                               G_FILE_ATTRIBUTE_ACCESS_CAN_READ))
-        {
-          g_set_error_literal (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
-                               _("Permission denied"));
-          g_object_unref (info);
-          return NULL;
-        }
-
-      g_object_unref (info);
     }
 
   if (! file_proc)
@@ -742,6 +749,11 @@ static void
 file_open_sanitize_image (GimpImage *image,
                           gboolean   as_new)
 {
+  /* This should never occur, but apparently it does sometimes #13702
+   * Avoids infinite loop in the while statement below.
+   */
+  g_return_if_fail (GIMP_IS_IMAGE (image));
+
   if (as_new)
     gimp_image_set_file (image, NULL);
 

app/file/file-utils.c

@@ -222,6 +222,10 @@ file_utils_save_thumbnail (GimpImage *image,
   g_return_val_if_fail (G_IS_FILE (file), FALSE);
 
   image_file = gimp_image_get_file (image);
+  if (! image_file)
+    image_file = gimp_image_get_exported_file (image);
+  if (! image_file)
+    image_file = gimp_image_get_imported_file (image);
 
   if (image_file)
     {

app/gegl/gimp-gegl-utils.c

@@ -535,6 +535,8 @@ gimp_gegl_op_blacklisted (const gchar *name,
     "gegl:high-pass",
     "gegl:hue-chroma",
     "gegl:illusion",
+    "gegl:json:dropshadow2",
+    "gegl:json:grey2",
     "gegl:image-gradient",
     "gegl:invert-linear",
     "gegl:invert-gamma",
@@ -614,7 +616,7 @@ gimp_gegl_op_blacklisted (const gchar *name,
     "gegl:ditto", /* pointless */
     "gegl:fill-path",
     "gegl:gray", /* we use gimp's op */
-    "gegl:hstack", /* pointless */
+    "gegl:hstack", /* deleted from GEGL and replaced by gegl:pack */
     "gegl:introspect", /* pointless */
     "gegl:layer", /* we use gimp's ops */
     "gegl:lcms-from-profile", /* not usable here */
@@ -624,6 +626,7 @@ gimp_gegl_op_blacklisted (const gchar *name,
     "gegl:matting-global", /* used in the foreground select tool */
     "gegl:matting-levin", /* used in the foreground select tool */
     "gegl:opacity", /* poinless */
+    "gegl:pack", /* pointless */
     "gegl:path",
     "gegl:posterize", /* we use gimp's op */
     "gegl:radial-gradient", /* we use the blend tool */

app/gegl/gimpapplicator.c

@@ -466,14 +466,18 @@ gimp_applicator_set_affect (GimpApplicator    *applicator,
     }
 }
 
-void
+gboolean
 gimp_applicator_set_output_format (GimpApplicator *applicator,
                                    const Babl     *format)
 {
-  g_return_if_fail (GIMP_IS_APPLICATOR (applicator));
+  gboolean changed = FALSE;
+
+  g_return_val_if_fail (GIMP_IS_APPLICATOR (applicator), FALSE);
 
   if (applicator->output_format != format)
     {
+      changed = TRUE;
+
       if (format)
         {
           if (! applicator->output_format)
@@ -499,6 +503,8 @@ gimp_applicator_set_output_format (GimpApplicator *applicator,
 
       applicator->output_format = format;
     }
+
+  return changed;
 }
 
 const Babl *

app/gegl/gimpapplicator.h

@@ -124,7 +124,7 @@ void         gimp_applicator_set_mode          (GimpApplicator       *applicator
 void         gimp_applicator_set_affect        (GimpApplicator       *applicator,
                                                 GimpComponentMask     affect);
 
-void         gimp_applicator_set_output_format (GimpApplicator       *applicator,
+gboolean     gimp_applicator_set_output_format (GimpApplicator       *applicator,
                                                 const Babl           *format);
 const Babl * gimp_applicator_get_output_format (GimpApplicator       *applicator);
 

app/language.c

@@ -793,14 +793,13 @@ language_init (const gchar  *language,
 static gchar *
 language_get_system_lang_id (void)
 {
-  const gchar *syslang = NULL;
-
   /* Using system language. It doesn't matter too much that the string
    * format is different when using system or preference-set language,
    * because this string is only used for comparison. As long as 2
    * similar run have the same settings, the strings will be
    * identical.
    */
+
 #if defined G_OS_WIN32
   return g_strdup_printf ("LANGID-%d", GetUserDefaultUILanguage());
 #elif defined PLATFORM_OSX
@@ -818,7 +817,28 @@ language_get_system_lang_id (void)
   langs = [[NSLocale preferredLanguages] componentsJoinedByString:@","];
 
   return g_strdup_printf ("%s", [langs UTF8String]);
-#elif defined HAVE__NL_IDENTIFICATION_LANGUAGE
+#else
+  const gchar *syslang = NULL;
+  const gchar *language;
+
+  /* nl_langinfo() does not take LANGUAGE into account, only the `LC_*`
+   * variables apparently. Even though the GUI is correctly translated
+   * to LANGUAGE, syslang can end wrong. See #12722.
+   *
+   * This is why I return the concatenation of LANGUAGE (even though
+   * this variable may contain bogus data and therefore not reflect the
+   * real GUI language either) and the locale language.
+   *
+   * Since the returned string is mostly used to detect if we should
+   * trigger a re-query of all plug-ins (after a localization change),
+   * it is considered an opaque value.
+   * It may trigger unneeded force-query, but only if people play with
+   * environment variables and set different bogus language codes all
+   * the time. At least it wouldn't block force-query for real cases.
+   */
+  language = g_getenv ("LANGUAGE");
+
+#if defined HAVE__NL_IDENTIFICATION_LANGUAGE
   syslang = nl_langinfo (_NL_IDENTIFICATION_LANGUAGE);
 #endif
 
@@ -833,8 +853,6 @@ language_get_system_lang_id (void)
    * let's just check environment variables ourselves.
    * This is the proper order of priority.
    */
-  if (syslang == NULL || strlen (syslang) == 0)
-    syslang = g_getenv ("LANGUAGE");
   if (syslang == NULL || strlen (syslang) == 0)
     syslang = g_getenv ("LC_ALL");
   if (syslang == NULL || strlen (syslang) == 0)
@@ -842,5 +860,13 @@ language_get_system_lang_id (void)
   if (syslang == NULL || strlen (syslang) == 0)
     syslang = g_getenv ("LANG");
 
-  return syslang && strlen (syslang) > 0 ? g_strdup (syslang) : NULL;
+  if (syslang && strlen (syslang) > 0 && language && strlen (language) > 0)
+    return g_strjoin ("-", language, syslang, NULL);
+  else if (syslang && strlen (syslang) > 0)
+    return g_strdup (syslang);
+  else if (language && strlen (language) > 0)
+    return g_strdup (language);
+  else
+    return NULL;
+#endif
 }

app/main.c

@@ -595,6 +595,15 @@ main (int    argc,
   gimp_init_signal_handlers (&backtrace_file);
 
 #ifdef G_OS_WIN32
+  /* Make Inno aware of gimp process avoiding broken install/unninstall */
+  char    *utf8_name = g_strdup_printf ("GIMP-%s", GIMP_MUTEX_VERSION);
+  wchar_t *name      = g_utf8_to_utf16 (utf8_name, -1, NULL, NULL, NULL);
+  
+  CreateMutexW (NULL, FALSE, name);
+  
+  g_free (utf8_name);
+  g_free (name);
+  
   /* Enable Anti-Aliasing*/
   g_setenv ("PANGOCAIRO_BACKEND", "fc", TRUE);
 

app/menus/windows-menu.c

@@ -265,5 +265,14 @@ windows_menu_recent_remove (GimpContainer   *container,
                             GimpSessionInfo *info,
                             GimpUIManager   *manager)
 {
-  gimp_ui_manager_remove_uis (manager, "windows-recent-");
+  gchar *action_name;
+  gint   info_id;
+
+  info_id = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (info), "recent-action-id"));
+
+  action_name = g_strdup_printf ("windows-recent-%04d", info_id);
+
+  gimp_ui_manager_remove_uis (manager, action_name);
+
+  g_free (action_name);
 }

app/meson.build

@@ -240,12 +240,10 @@ if enable_default_bin
                     pointing_to: fs.name(gimpmain_exe.full_path()),
                     install_dir: get_option('bindir'))
   else
-    meson.add_install_script('sh', '-c',
-                             'cp -f "@0@" "$MESON_INSTALL_DESTDIR_PREFIX/bin/@1@"'.format(gimpmain_exe.full_path(),
-                                                                                          fs.name(gimpmain_exe.name()).replace(exec_ver, '.exe')))
-    meson.add_install_script('sh', '-c',
-                             'cp -f "@0@" "$MESON_INSTALL_DESTDIR_PREFIX/bin/@1@"'.format(gimpmain_exe.full_path(),
-                                                                                          fs.name(gimpmain_exe.name()).replace(exec_ver, '-@0@.exe'.format(api_version_major))))
+    meson.add_install_script(python, '-c', 'from shutil import copy2; from pathlib import Path; from sys import argv; copy2(argv[1], str(Path(argv[2]) / "bin" / argv[3]))',
+                             gimpmain_exe.full_path(), get_option('prefix'), fs.name(gimpmain_exe.name()).replace(exec_ver, '.exe'))
+    meson.add_install_script(python, '-c', 'from shutil import copy2; from pathlib import Path; from sys import argv; copy2(argv[1], str(Path(argv[2]) / "bin" / argv[3].replace("@0@", argv[4])))',
+                             gimpmain_exe.full_path(), get_option('prefix'), fs.name(gimpmain_exe.name()).replace(exec_ver, '-@0@.exe'), api_version_major.to_string())
   endif
   if enable_console_bin
     if not platform_windows
@@ -256,12 +254,10 @@ if enable_default_bin
                       pointing_to: fs.name(gimpconsole_exe.full_path()),
                       install_dir: get_option('bindir'))
     else
-      meson.add_install_script('sh', '-c',
-                               'cp -f "@0@" "$MESON_INSTALL_DESTDIR_PREFIX/bin/@1@"'.format(gimpconsole_exe.full_path(),
-                                                                                            fs.name(gimpconsole_exe.name()).replace(exec_ver, '.exe')))
-      meson.add_install_script('sh', '-c',
-                               'cp -f "@0@" "$MESON_INSTALL_DESTDIR_PREFIX/bin/@1@"'.format(gimpconsole_exe.full_path(),
-                                                                                            fs.name(gimpconsole_exe.name()).replace(exec_ver, '-@0@.exe'.format(api_version_major))))
+      meson.add_install_script(python, '-c', 'from shutil import copy2; from pathlib import Path; from sys import argv; copy2(argv[1], str(Path(argv[2]) / "bin" / argv[3]))',
+                               gimpconsole_exe.full_path(), get_option('prefix'), fs.name(gimpconsole_exe.name()).replace(exec_ver, '.exe'))
+      meson.add_install_script(python, '-c', 'from shutil import copy2; from pathlib import Path; from sys import argv; copy2(argv[1], str(Path(argv[2]) / "bin" / argv[3].replace("@0@", argv[4])))',
+                               gimpconsole_exe.full_path(), get_option('prefix'), fs.name(gimpconsole_exe.name()).replace(exec_ver, '-@0@.exe'), api_version_major.to_string())
     endif
   endif
 endif

app/operations/layer-modes/gimpoperationlayermode.c

@@ -68,6 +68,7 @@ typedef void (* CompositeFunc) (const gfloat *in,
                                 gint          samples);
 
 
+static void            gimp_operation_layer_mode_finalize            (GObject                *object);
 static void            gimp_operation_layer_mode_set_property        (GObject                *object,
                                                                       guint                   property_id,
                                                                       const GValue           *value,
@@ -117,8 +118,11 @@ static gboolean        process_last_node                             (GeglOperat
                                                                       const GeglRectangle *roi,
                                                                       gint                 level);
 
-static void            gimp_operation_layer_mode_cache_fishes        (GimpOperationLayerMode *op,
-                                                                      const Babl             *preferred_format);
+static void            gimp_operation_layer_mode_cache_fishes        (GimpOperationLayerMode  *op,
+                                                                      const Babl              *preferred_format,
+                                                                      const Babl             **out_format,
+                                                                      const Babl             **composite_to_blend_fish,
+                                                                      const Babl             **blend_to_composite_fish);
 
 
 G_DEFINE_TYPE (GimpOperationLayerMode, gimp_operation_layer_mode,
@@ -147,6 +151,7 @@ gimp_operation_layer_mode_class_init (GimpOperationLayerModeClass *klass)
   gegl_operation_class_set_keys (operation_class,
                                  "name", "gimp:layer-mode", NULL);
 
+  object_class->finalize            = gimp_operation_layer_mode_finalize;
   object_class->set_property        = gimp_operation_layer_mode_set_property;
   object_class->get_property        = gimp_operation_layer_mode_get_property;
 
@@ -210,6 +215,17 @@ gimp_operation_layer_mode_class_init (GimpOperationLayerModeClass *klass)
 static void
 gimp_operation_layer_mode_init (GimpOperationLayerMode *self)
 {
+  g_rw_lock_init (&self->cache_lock);
+}
+
+static void
+gimp_operation_layer_mode_finalize (GObject *object)
+{
+  GimpOperationLayerMode *mode = GIMP_OPERATION_LAYER_MODE (object);
+
+  g_rw_lock_clear (&mode->cache_lock);
+
+  G_OBJECT_CLASS (parent_class)->finalize (object);
 }
 
 static void
@@ -344,13 +360,7 @@ gimp_operation_layer_mode_prepare (GeglOperation *operation)
 
   self->has_mask = mask_extent && ! gegl_rectangle_is_empty (mask_extent);
 
-  gimp_operation_layer_mode_cache_fishes (self, preferred_format);
-
-  format = gimp_layer_mode_get_format (self->layer_mode,
-                                       self->blend_space,
-                                       self->composite_space,
-                                       self->composite_mode,
-                                       preferred_format);
+  gimp_operation_layer_mode_cache_fishes (self, preferred_format, &format, NULL, NULL);
 
   gegl_operation_set_format (operation, "input",  format);
   gegl_operation_set_format (operation, "output", format);
@@ -615,8 +625,6 @@ gimp_operation_layer_mode_real_process (GeglOperation       *operation,
   gfloat                 *layer                   = layer_p;
   gfloat                 *mask                    = mask_p;
   gfloat                  opacity                 = layer_mode->opacity;
-  GimpLayerColorSpace     blend_space             = layer_mode->blend_space;
-  GimpLayerColorSpace     composite_space         = layer_mode->composite_space;
   GimpLayerCompositeMode  composite_mode          = layer_mode->composite_mode;
   GimpLayerModeBlendFunc  blend_function          = layer_mode->blend_function;
   gboolean                composite_needs_in_color;
@@ -655,21 +663,12 @@ gimp_operation_layer_mode_real_process (GeglOperation       *operation,
   blend_layer = layer;
   blend_out   = out;
 
-  if (blend_space != GIMP_LAYER_COLOR_SPACE_AUTO)
-    {
-      gimp_assert (composite_space >= 1 && composite_space < 5);
-      gimp_assert (blend_space     >= 1 && blend_space     < 5);
-
-      /* Make sure the cache is set up from the start as the
-       * operation's prepare() method may have not been run yet.
-       */
-      gimp_operation_layer_mode_cache_fishes (layer_mode, NULL);
-      composite_to_blend_fish = layer_mode->space_fish [composite_space - 1]
-                                                       [blend_space     - 1];
-
-      blend_to_composite_fish = layer_mode->space_fish [blend_space     - 1]
-                                                       [composite_space - 1];
-    }
+  /* Make sure the cache is set up from the start as the
+   * operation's prepare() method may have not been run yet.
+   */
+  gimp_operation_layer_mode_cache_fishes (layer_mode, NULL, NULL,
+                                          &composite_to_blend_fish,
+                                          &blend_to_composite_fish);
 
   /* if we need to convert the samples between the composite and blend
    * spaces...
@@ -874,10 +873,27 @@ process_last_node (GeglOperation       *operation,
 }
 
 static void
-gimp_operation_layer_mode_cache_fishes (GimpOperationLayerMode *op,
-                                        const Babl             *preferred_format)
+gimp_operation_layer_mode_cache_fishes (GimpOperationLayerMode  *op,
+                                        const Babl              *preferred_format,
+                                        const Babl             **layer_mode_format,
+                                        const Babl             **composite_to_blend_fish,
+                                        const Babl             **blend_to_composite_fish)
 {
   const Babl *format;
+  gboolean    update_cache = FALSE;
+
+  g_rw_lock_reader_lock (&op->cache_lock);
+
+  gimp_assert (op->composite_space >= GIMP_LAYER_COLOR_SPACE_AUTO &&
+               op->composite_space < GIMP_LAYER_COLOR_SPACE_LAST);
+  gimp_assert (op->blend_space     >= GIMP_LAYER_COLOR_SPACE_AUTO &&
+               op->blend_space     < GIMP_LAYER_COLOR_SPACE_LAST);
+
+  /* XXX I am not why but some old code already had some assert that the
+   * composite_space would not be AUTO when blend_space is not.
+   */
+  if (op->blend_space != GIMP_LAYER_COLOR_SPACE_AUTO)
+    gimp_assert (op->composite_space != GIMP_LAYER_COLOR_SPACE_AUTO);
 
   if (! preferred_format)
     {
@@ -896,82 +912,123 @@ gimp_operation_layer_mode_cache_fishes (GimpOperationLayerMode *op,
                                        op->composite_space,
                                        op->composite_mode,
                                        preferred_format);
+
   if (op->cached_fish_format != format)
     {
-      op->cached_fish_format = format;
-
-      op->space_fish
-        /* from */ [GIMP_LAYER_COLOR_SPACE_RGB_LINEAR     - 1]
-        /* to   */ [GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL - 1] =
-          babl_fish (babl_format_with_space ("RGBA float", format),
-                     babl_format_with_space ("R~G~B~A float", format));
-
-      op->space_fish
-        /* from */ [GIMP_LAYER_COLOR_SPACE_RGB_LINEAR     - 1]
-        /* to   */ [GIMP_LAYER_COLOR_SPACE_RGB_NON_LINEAR - 1] =
-          babl_fish (babl_format_with_space ("RGBA float", format),
-                     babl_format_with_space ("R'G'B'A float", format));
-
-      op->space_fish
-        /* from */ [GIMP_LAYER_COLOR_SPACE_RGB_LINEAR     - 1]
-        /* to   */ [GIMP_LAYER_COLOR_SPACE_LAB            - 1] =
-          babl_fish (babl_format_with_space ("RGBA float", format),
-                     babl_format_with_space ("CIE Lab alpha float", format));
-
-      op->space_fish
-        /* from */ [GIMP_LAYER_COLOR_SPACE_RGB_NON_LINEAR - 1]
-        /* to   */ [GIMP_LAYER_COLOR_SPACE_RGB_LINEAR     - 1] =
-          babl_fish (babl_format_with_space("R'G'B'A float", format),
-                     babl_format_with_space ( "RGBA float", format));
-
-      op->space_fish
-        /* from */ [GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL - 1]
-        /* to   */ [GIMP_LAYER_COLOR_SPACE_RGB_LINEAR     - 1] =
-          babl_fish (babl_format_with_space("R~G~B~A float", format),
-                     babl_format_with_space ( "RGBA float", format));
-
-      op->space_fish
-        /* from */ [GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL - 1]
-        /* to   */ [GIMP_LAYER_COLOR_SPACE_LAB            - 1] =
-          babl_fish (babl_format_with_space("R~G~B~A float", format),
-                     babl_format_with_space ( "CIE Lab alpha float", format));
-
-      op->space_fish
-        /* from */ [GIMP_LAYER_COLOR_SPACE_RGB_NON_LINEAR - 1]
-        /* to   */ [GIMP_LAYER_COLOR_SPACE_LAB            - 1] =
-          babl_fish (babl_format_with_space("R'G'B'A float", format),
-                     babl_format_with_space ( "CIE Lab alpha float", format));
-
-      op->space_fish
-        /* from */ [GIMP_LAYER_COLOR_SPACE_LAB            - 1]
-        /* to   */ [GIMP_LAYER_COLOR_SPACE_RGB_LINEAR     - 1] =
-          babl_fish (babl_format_with_space("CIE Lab alpha float", format),
-                     babl_format_with_space ( "RGBA float", format));
-
-      op->space_fish
-        /* from */ [GIMP_LAYER_COLOR_SPACE_LAB            - 1]
-        /* to   */ [GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL - 1] =
-          babl_fish (babl_format_with_space("CIE Lab alpha float", format),
-                     babl_format_with_space ( "R~G~B~A float", format));
-
-      op->space_fish
-        /* from */ [GIMP_LAYER_COLOR_SPACE_LAB            - 1]
-        /* to   */ [GIMP_LAYER_COLOR_SPACE_RGB_NON_LINEAR - 1] =
-          babl_fish (babl_format_with_space("CIE Lab alpha float", format),
-                     babl_format_with_space ( "R'G'B'A float", format));
-
-      op->space_fish
-        /* from */ [GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL - 1]
-        /* to   */ [GIMP_LAYER_COLOR_SPACE_RGB_NON_LINEAR - 1] =
-          babl_fish (babl_format_with_space("R~G~B~A float", format),
-                     babl_format_with_space ( "R'G'B'A float", format));
-
-      op->space_fish
-        /* from */ [GIMP_LAYER_COLOR_SPACE_RGB_NON_LINEAR - 1]
-        /* to   */ [GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL - 1] =
-          babl_fish (babl_format_with_space("R'G'B'A float", format),
-                     babl_format_with_space ( "R~G~B~A float", format));
+      g_rw_lock_reader_unlock (&op->cache_lock);
+      update_cache = TRUE;
     }
+
+  if (update_cache)
+    {
+      g_rw_lock_writer_lock (&op->cache_lock);
+
+      /* We recheck because it is possible that in-between the point we
+       * released the read lock and got our write lock, another thread
+       * also modified the cache (to the same values).
+       * No need to redo the same thing twice.
+       */
+      if (op->cached_fish_format != format)
+        {
+          op->cached_fish_format = format;
+
+          op->space_fish
+            /* from */ [GIMP_LAYER_COLOR_SPACE_RGB_LINEAR     - 1]
+            /* to   */ [GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL - 1] =
+            babl_fish (babl_format_with_space ("RGBA float", format),
+                       babl_format_with_space ("R~G~B~A float", format));
+
+          op->space_fish
+            /* from */ [GIMP_LAYER_COLOR_SPACE_RGB_LINEAR     - 1]
+            /* to   */ [GIMP_LAYER_COLOR_SPACE_RGB_NON_LINEAR - 1] =
+            babl_fish (babl_format_with_space ("RGBA float", format),
+                       babl_format_with_space ("R'G'B'A float", format));
+
+          op->space_fish
+            /* from */ [GIMP_LAYER_COLOR_SPACE_RGB_LINEAR     - 1]
+            /* to   */ [GIMP_LAYER_COLOR_SPACE_LAB            - 1] =
+            babl_fish (babl_format_with_space ("RGBA float", format),
+                       babl_format_with_space ("CIE Lab alpha float", format));
+
+          op->space_fish
+            /* from */ [GIMP_LAYER_COLOR_SPACE_RGB_NON_LINEAR - 1]
+            /* to   */ [GIMP_LAYER_COLOR_SPACE_RGB_LINEAR     - 1] =
+            babl_fish (babl_format_with_space("R'G'B'A float", format),
+                       babl_format_with_space ( "RGBA float", format));
+
+          op->space_fish
+            /* from */ [GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL - 1]
+            /* to   */ [GIMP_LAYER_COLOR_SPACE_RGB_LINEAR     - 1] =
+            babl_fish (babl_format_with_space("R~G~B~A float", format),
+                       babl_format_with_space ( "RGBA float", format));
+
+          op->space_fish
+            /* from */ [GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL - 1]
+            /* to   */ [GIMP_LAYER_COLOR_SPACE_LAB            - 1] =
+            babl_fish (babl_format_with_space("R~G~B~A float", format),
+                       babl_format_with_space ( "CIE Lab alpha float", format));
+
+          op->space_fish
+            /* from */ [GIMP_LAYER_COLOR_SPACE_RGB_NON_LINEAR - 1]
+            /* to   */ [GIMP_LAYER_COLOR_SPACE_LAB            - 1] =
+            babl_fish (babl_format_with_space("R'G'B'A float", format),
+                       babl_format_with_space ( "CIE Lab alpha float", format));
+
+          op->space_fish
+            /* from */ [GIMP_LAYER_COLOR_SPACE_LAB            - 1]
+            /* to   */ [GIMP_LAYER_COLOR_SPACE_RGB_LINEAR     - 1] =
+            babl_fish (babl_format_with_space("CIE Lab alpha float", format),
+                       babl_format_with_space ( "RGBA float", format));
+
+          op->space_fish
+            /* from */ [GIMP_LAYER_COLOR_SPACE_LAB            - 1]
+            /* to   */ [GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL - 1] =
+            babl_fish (babl_format_with_space("CIE Lab alpha float", format),
+                       babl_format_with_space ( "R~G~B~A float", format));
+
+          op->space_fish
+            /* from */ [GIMP_LAYER_COLOR_SPACE_LAB            - 1]
+            /* to   */ [GIMP_LAYER_COLOR_SPACE_RGB_NON_LINEAR - 1] =
+            babl_fish (babl_format_with_space("CIE Lab alpha float", format),
+                       babl_format_with_space ( "R'G'B'A float", format));
+
+          op->space_fish
+            /* from */ [GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL - 1]
+            /* to   */ [GIMP_LAYER_COLOR_SPACE_RGB_NON_LINEAR - 1] =
+            babl_fish (babl_format_with_space("R~G~B~A float", format),
+                       babl_format_with_space ( "R'G'B'A float", format));
+
+          op->space_fish
+            /* from */ [GIMP_LAYER_COLOR_SPACE_RGB_NON_LINEAR - 1]
+            /* to   */ [GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL - 1] =
+            babl_fish (babl_format_with_space("R'G'B'A float", format),
+                       babl_format_with_space ( "R~G~B~A float", format));
+        }
+    }
+
+  if (layer_mode_format)
+    *layer_mode_format = format;
+  if (composite_to_blend_fish)
+    {
+      if (op->blend_space != GIMP_LAYER_COLOR_SPACE_AUTO &&
+          op->composite_space != GIMP_LAYER_COLOR_SPACE_AUTO)
+        *composite_to_blend_fish = op->space_fish[op->composite_space - 1][op->blend_space - 1];
+      else
+        *composite_to_blend_fish = NULL;
+    }
+  if (blend_to_composite_fish)
+    {
+      if (op->blend_space != GIMP_LAYER_COLOR_SPACE_AUTO &&
+          op->composite_space != GIMP_LAYER_COLOR_SPACE_AUTO)
+        *blend_to_composite_fish = op->space_fish[op->blend_space - 1][op->composite_space - 1];
+      else
+        *blend_to_composite_fish = NULL;
+    }
+
+  if (update_cache)
+    g_rw_lock_writer_unlock (&op->cache_lock);
+  else
+    g_rw_lock_reader_unlock (&op->cache_lock);
 }
 
 

app/operations/layer-modes/gimpoperationlayermode.h

@@ -46,6 +46,7 @@ struct _GimpOperationLayerMode
   GimpLayerCompositeMode       composite_mode;
   const Babl                  *cached_fish_format;
   const Babl                  *space_fish[4 /* from */][4 /* to */];
+  GRWLock                      cache_lock;
 
   gdouble                      prop_opacity;
   GimpLayerCompositeMode       prop_composite_mode;

app/operations/operations-enums.h

@@ -32,6 +32,7 @@ typedef enum
   GIMP_LAYER_COLOR_SPACE_RGB_NON_LINEAR, /*< desc="RGB (from color profile)" >*/
   GIMP_LAYER_COLOR_SPACE_LAB,            /*< desc="LAB"              >*/
   GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL, /*< desc="RGB (perceptual)" >*/
+  GIMP_LAYER_COLOR_SPACE_LAST,           /*< pdb-skip, skip          >*/
 } GimpLayerColorSpace;
 
 

app/paint/gimppaintcore.c

@@ -1084,7 +1084,7 @@ gimp_paint_core_expand_drawable (GimpPaintCore    *core,
       core->canvas_buffer = new_buffer;
 
       gimp_get_fill_params (context, fill_type, &color, &pattern, NULL);
-      if (! gimp_drawable_has_alpha (drawable))
+      if (color && ! gimp_drawable_has_alpha (drawable))
         gimp_color_set_alpha (color, 1.0);
 
       undo_buffer = g_hash_table_lookup (core->undo_buffers, drawable);

app/paint/gimpsmudge.c

@@ -504,23 +504,24 @@ gimp_smudge_motion (GimpPaintCore    *paint_core,
                                                   TRUE);
         }
 
-      gimp_gegl_smudge_with_paint (accum_buffer,
-                                   GEGL_RECTANGLE (paint_buffer_x - x,
-                                                   paint_buffer_y - y,
-                                                   paint_buffer_width,
-                                                   paint_buffer_height),
-                                   gimp_pickable_get_buffer (dest_pickable),
-                                   GEGL_RECTANGLE (paint_buffer_x +
-                                                   dest_pickable_off_x,
-                                                   paint_buffer_y +
-                                                   dest_pickable_off_y,
-                                                   paint_buffer_width,
-                                                   paint_buffer_height),
-                                   brush_color,
-                                   paint_buffer,
-                                   options->no_erasing,
-                                   flow,
-                                   rate);
+      if (accum_buffer)
+        gimp_gegl_smudge_with_paint (accum_buffer,
+                                     GEGL_RECTANGLE (paint_buffer_x - x,
+                                                     paint_buffer_y - y,
+                                                     paint_buffer_width,
+                                                     paint_buffer_height),
+                                     gimp_pickable_get_buffer (dest_pickable),
+                                     GEGL_RECTANGLE (paint_buffer_x +
+                                                     dest_pickable_off_x,
+                                                     paint_buffer_y +
+                                                     dest_pickable_off_y,
+                                                     paint_buffer_width,
+                                                     paint_buffer_height),
+                                     brush_color,
+                                     paint_buffer,
+                                     options->no_erasing,
+                                     flow,
+                                     rate);
 
       if (gimp_dynamics_is_output_enabled (dynamics, GIMP_DYNAMICS_OUTPUT_FORCE))
         force = gimp_dynamics_get_linear_value (dynamics,
@@ -553,10 +554,19 @@ gimp_smudge_accumulator_coords (GimpPaintCore    *paint_core,
   GimpSmudge *smudge = GIMP_SMUDGE (paint_core);
   GeglBuffer *accum_buffer;
 
-  accum_buffer = g_list_nth_data (smudge->accum_buffers, stroke);
+  *x = (gint) coords->x;
+  *y = (gint) coords->y;
 
-  *x = (gint) coords->x - gegl_buffer_get_width  (accum_buffer) / 2;
-  *y = (gint) coords->y - gegl_buffer_get_height (accum_buffer) / 2;
+  if (smudge->accum_buffers)
+    {
+      accum_buffer = g_list_nth_data (smudge->accum_buffers, stroke);
+
+      if (accum_buffer)
+        {
+          *x -= gegl_buffer_get_width  (accum_buffer) / 2;
+          *y -= gegl_buffer_get_height (accum_buffer) / 2;
+        }
+    }
 }
 
 static void

app/pdb/brush-cmds.c

@@ -162,19 +162,22 @@ brush_get_info_invoker (GimpProcedure         *procedure,
     {
       GimpTempBuf *mask   = gimp_brush_get_mask (brush);
       GimpTempBuf *pixmap = gimp_brush_get_pixmap (brush);
-      const Babl  *format;
+      const Babl  *format = NULL;
 
-      format = gimp_babl_compat_u8_mask_format (
-        gimp_temp_buf_get_format (mask));
+      if (brush)
+        format = gimp_babl_compat_u8_mask_format (gimp_temp_buf_get_format (mask));
 
       width    = gimp_brush_get_width  (brush);
       height   = gimp_brush_get_height (brush);
-      mask_bpp = babl_format_get_bytes_per_pixel (format);
 
-      if (pixmap)
+      if (format)
+        mask_bpp = babl_format_get_bytes_per_pixel (format);
+      else
+        mask_bpp = 0;
+
+      if (pixmap && format)
         {
-          format = gimp_babl_compat_u8_format (
-            gimp_temp_buf_get_format (pixmap));
+          format = gimp_babl_compat_u8_format (gimp_temp_buf_get_format (pixmap));
 
           color_bpp = babl_format_get_bytes_per_pixel (format);
         }
@@ -770,7 +773,7 @@ register_brush_procs (GimpPDB *pdb)
   /*
    * gimp-brush-new
    */
-  procedure = gimp_procedure_new (brush_new_invoker);
+  procedure = gimp_procedure_new (brush_new_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-brush-new");
   gimp_procedure_set_static_help (procedure,
@@ -802,7 +805,7 @@ register_brush_procs (GimpPDB *pdb)
   /*
    * gimp-brush-get-by-name
    */
-  procedure = gimp_procedure_new (brush_get_by_name_invoker);
+  procedure = gimp_procedure_new (brush_get_by_name_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-brush-get-by-name");
   gimp_procedure_set_static_help (procedure,
@@ -834,7 +837,7 @@ register_brush_procs (GimpPDB *pdb)
   /*
    * gimp-brush-is-generated
    */
-  procedure = gimp_procedure_new (brush_is_generated_invoker);
+  procedure = gimp_procedure_new (brush_is_generated_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-brush-is-generated");
   gimp_procedure_set_static_help (procedure,
@@ -865,7 +868,7 @@ register_brush_procs (GimpPDB *pdb)
   /*
    * gimp-brush-get-info
    */
-  procedure = gimp_procedure_new (brush_get_info_invoker);
+  procedure = gimp_procedure_new (brush_get_info_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-brush-get-info");
   gimp_procedure_set_static_help (procedure,
@@ -914,7 +917,7 @@ register_brush_procs (GimpPDB *pdb)
   /*
    * gimp-brush-get-pixels
    */
-  procedure = gimp_procedure_new (brush_get_pixels_invoker);
+  procedure = gimp_procedure_new (brush_get_pixels_invoker, TRUE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-brush-get-pixels");
   gimp_procedure_set_static_help (procedure,
@@ -975,7 +978,7 @@ register_brush_procs (GimpPDB *pdb)
   /*
    * gimp-brush-get-spacing
    */
-  procedure = gimp_procedure_new (brush_get_spacing_invoker);
+  procedure = gimp_procedure_new (brush_get_spacing_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-brush-get-spacing");
   gimp_procedure_set_static_help (procedure,
@@ -1006,7 +1009,7 @@ register_brush_procs (GimpPDB *pdb)
   /*
    * gimp-brush-set-spacing
    */
-  procedure = gimp_procedure_new (brush_set_spacing_invoker);
+  procedure = gimp_procedure_new (brush_set_spacing_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-brush-set-spacing");
   gimp_procedure_set_static_help (procedure,
@@ -1037,7 +1040,7 @@ register_brush_procs (GimpPDB *pdb)
   /*
    * gimp-brush-get-shape
    */
-  procedure = gimp_procedure_new (brush_get_shape_invoker);
+  procedure = gimp_procedure_new (brush_get_shape_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-brush-get-shape");
   gimp_procedure_set_static_help (procedure,
@@ -1069,7 +1072,7 @@ register_brush_procs (GimpPDB *pdb)
   /*
    * gimp-brush-set-shape
    */
-  procedure = gimp_procedure_new (brush_set_shape_invoker);
+  procedure = gimp_procedure_new (brush_set_shape_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-brush-set-shape");
   gimp_procedure_set_static_help (procedure,
@@ -1108,7 +1111,7 @@ register_brush_procs (GimpPDB *pdb)
   /*
    * gimp-brush-get-radius
    */
-  procedure = gimp_procedure_new (brush_get_radius_invoker);
+  procedure = gimp_procedure_new (brush_get_radius_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-brush-get-radius");
   gimp_procedure_set_static_help (procedure,
@@ -1139,12 +1142,12 @@ register_brush_procs (GimpPDB *pdb)
   /*
    * gimp-brush-set-radius
    */
-  procedure = gimp_procedure_new (brush_set_radius_invoker);
+  procedure = gimp_procedure_new (brush_set_radius_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-brush-set-radius");
   gimp_procedure_set_static_help (procedure,
                                   "Sets the radius of a generated brush.",
-                                  "Sets the radius for a generated brush. Clamps radius to [0.0, 32767.0]. Returns the clamped value. Returns an error when brush is non-parametric or not editable.",
+                                  "Sets the radius for a generated brush. Clamps radius to [0.1, 4000.0]. Returns the clamped value. Returns an error when brush is non-parametric or not editable.",
                                   NULL);
   gimp_procedure_set_static_attribution (procedure,
                                          "Bill Skaggs <weskaggs@primate.ucdavis.edu>",
@@ -1176,7 +1179,7 @@ register_brush_procs (GimpPDB *pdb)
   /*
    * gimp-brush-get-spikes
    */
-  procedure = gimp_procedure_new (brush_get_spikes_invoker);
+  procedure = gimp_procedure_new (brush_get_spikes_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-brush-get-spikes");
   gimp_procedure_set_static_help (procedure,
@@ -1207,7 +1210,7 @@ register_brush_procs (GimpPDB *pdb)
   /*
    * gimp-brush-set-spikes
    */
-  procedure = gimp_procedure_new (brush_set_spikes_invoker);
+  procedure = gimp_procedure_new (brush_set_spikes_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-brush-set-spikes");
   gimp_procedure_set_static_help (procedure,
@@ -1244,7 +1247,7 @@ register_brush_procs (GimpPDB *pdb)
   /*
    * gimp-brush-get-hardness
    */
-  procedure = gimp_procedure_new (brush_get_hardness_invoker);
+  procedure = gimp_procedure_new (brush_get_hardness_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-brush-get-hardness");
   gimp_procedure_set_static_help (procedure,
@@ -1275,7 +1278,7 @@ register_brush_procs (GimpPDB *pdb)
   /*
    * gimp-brush-set-hardness
    */
-  procedure = gimp_procedure_new (brush_set_hardness_invoker);
+  procedure = gimp_procedure_new (brush_set_hardness_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-brush-set-hardness");
   gimp_procedure_set_static_help (procedure,
@@ -1312,7 +1315,7 @@ register_brush_procs (GimpPDB *pdb)
   /*
    * gimp-brush-get-aspect-ratio
    */
-  procedure = gimp_procedure_new (brush_get_aspect_ratio_invoker);
+  procedure = gimp_procedure_new (brush_get_aspect_ratio_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-brush-get-aspect-ratio");
   gimp_procedure_set_static_help (procedure,
@@ -1343,7 +1346,7 @@ register_brush_procs (GimpPDB *pdb)
   /*
    * gimp-brush-set-aspect-ratio
    */
-  procedure = gimp_procedure_new (brush_set_aspect_ratio_invoker);
+  procedure = gimp_procedure_new (brush_set_aspect_ratio_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-brush-set-aspect-ratio");
   gimp_procedure_set_static_help (procedure,
@@ -1380,7 +1383,7 @@ register_brush_procs (GimpPDB *pdb)
   /*
    * gimp-brush-get-angle
    */
-  procedure = gimp_procedure_new (brush_get_angle_invoker);
+  procedure = gimp_procedure_new (brush_get_angle_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-brush-get-angle");
   gimp_procedure_set_static_help (procedure,
@@ -1411,7 +1414,7 @@ register_brush_procs (GimpPDB *pdb)
   /*
    * gimp-brush-set-angle
    */
-  procedure = gimp_procedure_new (brush_set_angle_invoker);
+  procedure = gimp_procedure_new (brush_set_angle_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-brush-set-angle");
   gimp_procedure_set_static_help (procedure,

app/pdb/brush-select-cmds.c

@@ -144,7 +144,7 @@ register_brush_select_procs (GimpPDB *pdb)
   /*
    * gimp-brushes-popup
    */
-  procedure = gimp_procedure_new (brushes_popup_invoker);
+  procedure = gimp_procedure_new (brushes_popup_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-brushes-popup");
   gimp_procedure_set_static_help (procedure,
@@ -173,7 +173,7 @@ register_brush_select_procs (GimpPDB *pdb)
                                gimp_param_spec_brush ("initial-brush",
                                                       "initial brush",
                                                       "The brush to set as the initial choice",
-                                                      FALSE,
+                                                      TRUE,
                                                       NULL,
                                                       FALSE,
                                                       GIMP_PARAM_READWRITE));
@@ -189,7 +189,7 @@ register_brush_select_procs (GimpPDB *pdb)
   /*
    * gimp-brushes-close-popup
    */
-  procedure = gimp_procedure_new (brushes_close_popup_invoker);
+  procedure = gimp_procedure_new (brushes_close_popup_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-brushes-close-popup");
   gimp_procedure_set_static_help (procedure,
@@ -213,7 +213,7 @@ register_brush_select_procs (GimpPDB *pdb)
   /*
    * gimp-brushes-set-popup
    */
-  procedure = gimp_procedure_new (brushes_set_popup_invoker);
+  procedure = gimp_procedure_new (brushes_set_popup_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-brushes-set-popup");
   gimp_procedure_set_static_help (procedure,

app/pdb/brushes-cmds.c

@@ -96,7 +96,7 @@ register_brushes_procs (GimpPDB *pdb)
   /*
    * gimp-brushes-refresh
    */
-  procedure = gimp_procedure_new (brushes_refresh_invoker);
+  procedure = gimp_procedure_new (brushes_refresh_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-brushes-refresh");
   gimp_procedure_set_static_help (procedure,
@@ -113,7 +113,7 @@ register_brushes_procs (GimpPDB *pdb)
   /*
    * gimp-brushes-get-list
    */
-  procedure = gimp_procedure_new (brushes_get_list_invoker);
+  procedure = gimp_procedure_new (brushes_get_list_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-brushes-get-list");
   gimp_procedure_set_static_help (procedure,

app/pdb/buffer-cmds.c

@@ -288,7 +288,7 @@ register_buffer_procs (GimpPDB *pdb)
   /*
    * gimp-buffers-get-name-list
    */
-  procedure = gimp_procedure_new (buffers_get_name_list_invoker);
+  procedure = gimp_procedure_new (buffers_get_name_list_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-buffers-get-name-list");
   gimp_procedure_set_static_help (procedure,
@@ -318,7 +318,7 @@ register_buffer_procs (GimpPDB *pdb)
   /*
    * gimp-buffer-rename
    */
-  procedure = gimp_procedure_new (buffer_rename_invoker);
+  procedure = gimp_procedure_new (buffer_rename_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-buffer-rename");
   gimp_procedure_set_static_help (procedure,
@@ -356,7 +356,7 @@ register_buffer_procs (GimpPDB *pdb)
   /*
    * gimp-buffer-delete
    */
-  procedure = gimp_procedure_new (buffer_delete_invoker);
+  procedure = gimp_procedure_new (buffer_delete_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-buffer-delete");
   gimp_procedure_set_static_help (procedure,
@@ -380,7 +380,7 @@ register_buffer_procs (GimpPDB *pdb)
   /*
    * gimp-buffer-get-width
    */
-  procedure = gimp_procedure_new (buffer_get_width_invoker);
+  procedure = gimp_procedure_new (buffer_get_width_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-buffer-get-width");
   gimp_procedure_set_static_help (procedure,
@@ -410,7 +410,7 @@ register_buffer_procs (GimpPDB *pdb)
   /*
    * gimp-buffer-get-height
    */
-  procedure = gimp_procedure_new (buffer_get_height_invoker);
+  procedure = gimp_procedure_new (buffer_get_height_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-buffer-get-height");
   gimp_procedure_set_static_help (procedure,
@@ -440,7 +440,7 @@ register_buffer_procs (GimpPDB *pdb)
   /*
    * gimp-buffer-get-bytes
    */
-  procedure = gimp_procedure_new (buffer_get_bytes_invoker);
+  procedure = gimp_procedure_new (buffer_get_bytes_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-buffer-get-bytes");
   gimp_procedure_set_static_help (procedure,
@@ -470,7 +470,7 @@ register_buffer_procs (GimpPDB *pdb)
   /*
    * gimp-buffer-get-image-type
    */
-  procedure = gimp_procedure_new (buffer_get_image_type_invoker);
+  procedure = gimp_procedure_new (buffer_get_image_type_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-buffer-get-image-type");
   gimp_procedure_set_static_help (procedure,

app/pdb/channel-cmds.c

@@ -377,7 +377,7 @@ register_channel_procs (GimpPDB *pdb)
   /*
    * gimp-channel-new
    */
-  procedure = gimp_procedure_new (channel_new_invoker);
+  procedure = gimp_procedure_new (channel_new_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-channel-new");
   gimp_procedure_set_static_help (procedure,
@@ -444,7 +444,7 @@ register_channel_procs (GimpPDB *pdb)
   /*
    * gimp-channel-new-from-component
    */
-  procedure = gimp_procedure_new (channel_new_from_component_invoker);
+  procedure = gimp_procedure_new (channel_new_from_component_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-channel-new-from-component");
   gimp_procedure_set_static_help (procedure,
@@ -488,7 +488,7 @@ register_channel_procs (GimpPDB *pdb)
   /*
    * gimp-channel-copy
    */
-  procedure = gimp_procedure_new (channel_copy_invoker);
+  procedure = gimp_procedure_new (channel_copy_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-channel-copy");
   gimp_procedure_set_static_help (procedure,
@@ -518,7 +518,7 @@ register_channel_procs (GimpPDB *pdb)
   /*
    * gimp-channel-combine-masks
    */
-  procedure = gimp_procedure_new (channel_combine_masks_invoker);
+  procedure = gimp_procedure_new (channel_combine_masks_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-channel-combine-masks");
   gimp_procedure_set_static_help (procedure,
@@ -566,7 +566,7 @@ register_channel_procs (GimpPDB *pdb)
   /*
    * gimp-channel-get-show-masked
    */
-  procedure = gimp_procedure_new (channel_get_show_masked_invoker);
+  procedure = gimp_procedure_new (channel_get_show_masked_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-channel-get-show-masked");
   gimp_procedure_set_static_help (procedure,
@@ -595,7 +595,7 @@ register_channel_procs (GimpPDB *pdb)
   /*
    * gimp-channel-set-show-masked
    */
-  procedure = gimp_procedure_new (channel_set_show_masked_invoker);
+  procedure = gimp_procedure_new (channel_set_show_masked_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-channel-set-show-masked");
   gimp_procedure_set_static_help (procedure,
@@ -624,7 +624,7 @@ register_channel_procs (GimpPDB *pdb)
   /*
    * gimp-channel-get-opacity
    */
-  procedure = gimp_procedure_new (channel_get_opacity_invoker);
+  procedure = gimp_procedure_new (channel_get_opacity_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-channel-get-opacity");
   gimp_procedure_set_static_help (procedure,
@@ -653,7 +653,7 @@ register_channel_procs (GimpPDB *pdb)
   /*
    * gimp-channel-set-opacity
    */
-  procedure = gimp_procedure_new (channel_set_opacity_invoker);
+  procedure = gimp_procedure_new (channel_set_opacity_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-channel-set-opacity");
   gimp_procedure_set_static_help (procedure,
@@ -682,7 +682,7 @@ register_channel_procs (GimpPDB *pdb)
   /*
    * gimp-channel-get-color
    */
-  procedure = gimp_procedure_new (channel_get_color_invoker);
+  procedure = gimp_procedure_new (channel_get_color_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-channel-get-color");
   gimp_procedure_set_static_help (procedure,
@@ -712,7 +712,7 @@ register_channel_procs (GimpPDB *pdb)
   /*
    * gimp-channel-set-color
    */
-  procedure = gimp_procedure_new (channel_set_color_invoker);
+  procedure = gimp_procedure_new (channel_set_color_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-channel-set-color");
   gimp_procedure_set_static_help (procedure,

app/pdb/context-cmds.c

@@ -3125,7 +3125,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-push
    */
-  procedure = gimp_procedure_new (context_push_invoker);
+  procedure = gimp_procedure_new (context_push_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-push");
   gimp_procedure_set_static_help (procedure,
@@ -3142,7 +3142,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-pop
    */
-  procedure = gimp_procedure_new (context_pop_invoker);
+  procedure = gimp_procedure_new (context_pop_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-pop");
   gimp_procedure_set_static_help (procedure,
@@ -3159,7 +3159,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-defaults
    */
-  procedure = gimp_procedure_new (context_set_defaults_invoker);
+  procedure = gimp_procedure_new (context_set_defaults_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-defaults");
   gimp_procedure_set_static_help (procedure,
@@ -3176,7 +3176,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-list-paint-methods
    */
-  procedure = gimp_procedure_new (context_list_paint_methods_invoker);
+  procedure = gimp_procedure_new (context_list_paint_methods_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-list-paint-methods");
   gimp_procedure_set_static_help (procedure,
@@ -3199,7 +3199,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-paint-method
    */
-  procedure = gimp_procedure_new (context_get_paint_method_invoker);
+  procedure = gimp_procedure_new (context_get_paint_method_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-paint-method");
   gimp_procedure_set_static_help (procedure,
@@ -3223,7 +3223,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-paint-method
    */
-  procedure = gimp_procedure_new (context_set_paint_method_invoker);
+  procedure = gimp_procedure_new (context_set_paint_method_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-paint-method");
   gimp_procedure_set_static_help (procedure,
@@ -3247,7 +3247,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-stroke-method
    */
-  procedure = gimp_procedure_new (context_get_stroke_method_invoker);
+  procedure = gimp_procedure_new (context_get_stroke_method_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-stroke-method");
   gimp_procedure_set_static_help (procedure,
@@ -3271,7 +3271,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-stroke-method
    */
-  procedure = gimp_procedure_new (context_set_stroke_method_invoker);
+  procedure = gimp_procedure_new (context_set_stroke_method_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-stroke-method");
   gimp_procedure_set_static_help (procedure,
@@ -3295,7 +3295,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-foreground
    */
-  procedure = gimp_procedure_new (context_get_foreground_invoker);
+  procedure = gimp_procedure_new (context_get_foreground_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-foreground");
   gimp_procedure_set_static_help (procedure,
@@ -3319,7 +3319,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-foreground
    */
-  procedure = gimp_procedure_new (context_set_foreground_invoker);
+  procedure = gimp_procedure_new (context_set_foreground_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-foreground");
   gimp_procedure_set_static_help (procedure,
@@ -3343,7 +3343,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-background
    */
-  procedure = gimp_procedure_new (context_get_background_invoker);
+  procedure = gimp_procedure_new (context_get_background_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-background");
   gimp_procedure_set_static_help (procedure,
@@ -3367,7 +3367,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-background
    */
-  procedure = gimp_procedure_new (context_set_background_invoker);
+  procedure = gimp_procedure_new (context_set_background_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-background");
   gimp_procedure_set_static_help (procedure,
@@ -3391,7 +3391,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-default-colors
    */
-  procedure = gimp_procedure_new (context_set_default_colors_invoker);
+  procedure = gimp_procedure_new (context_set_default_colors_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-default-colors");
   gimp_procedure_set_static_help (procedure,
@@ -3408,7 +3408,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-swap-colors
    */
-  procedure = gimp_procedure_new (context_swap_colors_invoker);
+  procedure = gimp_procedure_new (context_swap_colors_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-swap-colors");
   gimp_procedure_set_static_help (procedure,
@@ -3425,7 +3425,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-opacity
    */
-  procedure = gimp_procedure_new (context_get_opacity_invoker);
+  procedure = gimp_procedure_new (context_get_opacity_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-opacity");
   gimp_procedure_set_static_help (procedure,
@@ -3448,7 +3448,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-opacity
    */
-  procedure = gimp_procedure_new (context_set_opacity_invoker);
+  procedure = gimp_procedure_new (context_set_opacity_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-opacity");
   gimp_procedure_set_static_help (procedure,
@@ -3471,7 +3471,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-paint-mode
    */
-  procedure = gimp_procedure_new (context_get_paint_mode_invoker);
+  procedure = gimp_procedure_new (context_get_paint_mode_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-paint-mode");
   gimp_procedure_set_static_help (procedure,
@@ -3495,7 +3495,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-paint-mode
    */
-  procedure = gimp_procedure_new (context_set_paint_mode_invoker);
+  procedure = gimp_procedure_new (context_set_paint_mode_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-paint-mode");
   gimp_procedure_set_static_help (procedure,
@@ -3519,7 +3519,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-line-width
    */
-  procedure = gimp_procedure_new (context_get_line_width_invoker);
+  procedure = gimp_procedure_new (context_get_line_width_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-line-width");
   gimp_procedure_set_static_help (procedure,
@@ -3542,7 +3542,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-line-width
    */
-  procedure = gimp_procedure_new (context_set_line_width_invoker);
+  procedure = gimp_procedure_new (context_set_line_width_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-line-width");
   gimp_procedure_set_static_help (procedure,
@@ -3567,7 +3567,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-line-width-unit
    */
-  procedure = gimp_procedure_new (context_get_line_width_unit_invoker);
+  procedure = gimp_procedure_new (context_get_line_width_unit_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-line-width-unit");
   gimp_procedure_set_static_help (procedure,
@@ -3592,7 +3592,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-line-width-unit
    */
-  procedure = gimp_procedure_new (context_set_line_width_unit_invoker);
+  procedure = gimp_procedure_new (context_set_line_width_unit_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-line-width-unit");
   gimp_procedure_set_static_help (procedure,
@@ -3619,7 +3619,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-line-cap-style
    */
-  procedure = gimp_procedure_new (context_get_line_cap_style_invoker);
+  procedure = gimp_procedure_new (context_get_line_cap_style_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-line-cap-style");
   gimp_procedure_set_static_help (procedure,
@@ -3643,7 +3643,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-line-cap-style
    */
-  procedure = gimp_procedure_new (context_set_line_cap_style_invoker);
+  procedure = gimp_procedure_new (context_set_line_cap_style_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-line-cap-style");
   gimp_procedure_set_static_help (procedure,
@@ -3669,7 +3669,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-line-join-style
    */
-  procedure = gimp_procedure_new (context_get_line_join_style_invoker);
+  procedure = gimp_procedure_new (context_get_line_join_style_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-line-join-style");
   gimp_procedure_set_static_help (procedure,
@@ -3693,7 +3693,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-line-join-style
    */
-  procedure = gimp_procedure_new (context_set_line_join_style_invoker);
+  procedure = gimp_procedure_new (context_set_line_join_style_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-line-join-style");
   gimp_procedure_set_static_help (procedure,
@@ -3718,7 +3718,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-line-miter-limit
    */
-  procedure = gimp_procedure_new (context_get_line_miter_limit_invoker);
+  procedure = gimp_procedure_new (context_get_line_miter_limit_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-line-miter-limit");
   gimp_procedure_set_static_help (procedure,
@@ -3741,7 +3741,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-line-miter-limit
    */
-  procedure = gimp_procedure_new (context_set_line_miter_limit_invoker);
+  procedure = gimp_procedure_new (context_set_line_miter_limit_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-line-miter-limit");
   gimp_procedure_set_static_help (procedure,
@@ -3767,7 +3767,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-line-dash-offset
    */
-  procedure = gimp_procedure_new (context_get_line_dash_offset_invoker);
+  procedure = gimp_procedure_new (context_get_line_dash_offset_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-line-dash-offset");
   gimp_procedure_set_static_help (procedure,
@@ -3790,7 +3790,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-line-dash-offset
    */
-  procedure = gimp_procedure_new (context_set_line_dash_offset_invoker);
+  procedure = gimp_procedure_new (context_set_line_dash_offset_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-line-dash-offset");
   gimp_procedure_set_static_help (procedure,
@@ -3815,7 +3815,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-line-dash-pattern
    */
-  procedure = gimp_procedure_new (context_get_line_dash_pattern_invoker);
+  procedure = gimp_procedure_new (context_get_line_dash_pattern_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-line-dash-pattern");
   gimp_procedure_set_static_help (procedure,
@@ -3837,7 +3837,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-line-dash-pattern
    */
-  procedure = gimp_procedure_new (context_set_line_dash_pattern_invoker);
+  procedure = gimp_procedure_new (context_set_line_dash_pattern_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-line-dash-pattern");
   gimp_procedure_set_static_help (procedure,
@@ -3863,7 +3863,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-brush
    */
-  procedure = gimp_procedure_new (context_get_brush_invoker);
+  procedure = gimp_procedure_new (context_get_brush_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-brush");
   gimp_procedure_set_static_help (procedure,
@@ -3888,7 +3888,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-brush
    */
-  procedure = gimp_procedure_new (context_set_brush_invoker);
+  procedure = gimp_procedure_new (context_set_brush_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-brush");
   gimp_procedure_set_static_help (procedure,
@@ -3913,7 +3913,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-brush-size
    */
-  procedure = gimp_procedure_new (context_get_brush_size_invoker);
+  procedure = gimp_procedure_new (context_get_brush_size_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-brush-size");
   gimp_procedure_set_static_help (procedure,
@@ -3936,7 +3936,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-brush-size
    */
-  procedure = gimp_procedure_new (context_set_brush_size_invoker);
+  procedure = gimp_procedure_new (context_set_brush_size_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-brush-size");
   gimp_procedure_set_static_help (procedure,
@@ -3959,7 +3959,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-brush-default-size
    */
-  procedure = gimp_procedure_new (context_set_brush_default_size_invoker);
+  procedure = gimp_procedure_new (context_set_brush_default_size_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-brush-default-size");
   gimp_procedure_set_static_help (procedure,
@@ -3976,7 +3976,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-brush-aspect-ratio
    */
-  procedure = gimp_procedure_new (context_get_brush_aspect_ratio_invoker);
+  procedure = gimp_procedure_new (context_get_brush_aspect_ratio_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-brush-aspect-ratio");
   gimp_procedure_set_static_help (procedure,
@@ -3999,7 +3999,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-brush-aspect-ratio
    */
-  procedure = gimp_procedure_new (context_set_brush_aspect_ratio_invoker);
+  procedure = gimp_procedure_new (context_set_brush_aspect_ratio_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-brush-aspect-ratio");
   gimp_procedure_set_static_help (procedure,
@@ -4022,7 +4022,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-brush-angle
    */
-  procedure = gimp_procedure_new (context_get_brush_angle_invoker);
+  procedure = gimp_procedure_new (context_get_brush_angle_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-brush-angle");
   gimp_procedure_set_static_help (procedure,
@@ -4045,7 +4045,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-brush-angle
    */
-  procedure = gimp_procedure_new (context_set_brush_angle_invoker);
+  procedure = gimp_procedure_new (context_set_brush_angle_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-brush-angle");
   gimp_procedure_set_static_help (procedure,
@@ -4068,7 +4068,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-brush-spacing
    */
-  procedure = gimp_procedure_new (context_get_brush_spacing_invoker);
+  procedure = gimp_procedure_new (context_get_brush_spacing_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-brush-spacing");
   gimp_procedure_set_static_help (procedure,
@@ -4091,7 +4091,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-brush-spacing
    */
-  procedure = gimp_procedure_new (context_set_brush_spacing_invoker);
+  procedure = gimp_procedure_new (context_set_brush_spacing_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-brush-spacing");
   gimp_procedure_set_static_help (procedure,
@@ -4114,7 +4114,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-brush-default-spacing
    */
-  procedure = gimp_procedure_new (context_set_brush_default_spacing_invoker);
+  procedure = gimp_procedure_new (context_set_brush_default_spacing_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-brush-default-spacing");
   gimp_procedure_set_static_help (procedure,
@@ -4131,7 +4131,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-brush-hardness
    */
-  procedure = gimp_procedure_new (context_get_brush_hardness_invoker);
+  procedure = gimp_procedure_new (context_get_brush_hardness_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-brush-hardness");
   gimp_procedure_set_static_help (procedure,
@@ -4154,7 +4154,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-brush-hardness
    */
-  procedure = gimp_procedure_new (context_set_brush_hardness_invoker);
+  procedure = gimp_procedure_new (context_set_brush_hardness_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-brush-hardness");
   gimp_procedure_set_static_help (procedure,
@@ -4177,7 +4177,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-brush-default-hardness
    */
-  procedure = gimp_procedure_new (context_set_brush_default_hardness_invoker);
+  procedure = gimp_procedure_new (context_set_brush_default_hardness_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-brush-default-hardness");
   gimp_procedure_set_static_help (procedure,
@@ -4194,7 +4194,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-brush-force
    */
-  procedure = gimp_procedure_new (context_get_brush_force_invoker);
+  procedure = gimp_procedure_new (context_get_brush_force_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-brush-force");
   gimp_procedure_set_static_help (procedure,
@@ -4217,7 +4217,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-brush-force
    */
-  procedure = gimp_procedure_new (context_set_brush_force_invoker);
+  procedure = gimp_procedure_new (context_set_brush_force_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-brush-force");
   gimp_procedure_set_static_help (procedure,
@@ -4240,7 +4240,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-dynamics-name
    */
-  procedure = gimp_procedure_new (context_get_dynamics_name_invoker);
+  procedure = gimp_procedure_new (context_get_dynamics_name_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-dynamics-name");
   gimp_procedure_set_static_help (procedure,
@@ -4265,7 +4265,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-dynamics-name
    */
-  procedure = gimp_procedure_new (context_set_dynamics_name_invoker);
+  procedure = gimp_procedure_new (context_set_dynamics_name_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-dynamics-name");
   gimp_procedure_set_static_help (procedure,
@@ -4289,7 +4289,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-are-dynamics-enabled
    */
-  procedure = gimp_procedure_new (context_are_dynamics_enabled_invoker);
+  procedure = gimp_procedure_new (context_are_dynamics_enabled_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-are-dynamics-enabled");
   gimp_procedure_set_static_help (procedure,
@@ -4312,7 +4312,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-enable-dynamics
    */
-  procedure = gimp_procedure_new (context_enable_dynamics_invoker);
+  procedure = gimp_procedure_new (context_enable_dynamics_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-enable-dynamics");
   gimp_procedure_set_static_help (procedure,
@@ -4335,7 +4335,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-emulate-brush-dynamics
    */
-  procedure = gimp_procedure_new (context_get_emulate_brush_dynamics_invoker);
+  procedure = gimp_procedure_new (context_get_emulate_brush_dynamics_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-emulate-brush-dynamics");
   gimp_procedure_set_static_help (procedure,
@@ -4358,7 +4358,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-emulate-brush-dynamics
    */
-  procedure = gimp_procedure_new (context_set_emulate_brush_dynamics_invoker);
+  procedure = gimp_procedure_new (context_set_emulate_brush_dynamics_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-emulate-brush-dynamics");
   gimp_procedure_set_static_help (procedure,
@@ -4381,7 +4381,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-mypaint-brush
    */
-  procedure = gimp_procedure_new (context_get_mypaint_brush_invoker);
+  procedure = gimp_procedure_new (context_get_mypaint_brush_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-mypaint-brush");
   gimp_procedure_set_static_help (procedure,
@@ -4405,7 +4405,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-mypaint-brush
    */
-  procedure = gimp_procedure_new (context_set_mypaint_brush_invoker);
+  procedure = gimp_procedure_new (context_set_mypaint_brush_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-mypaint-brush");
   gimp_procedure_set_static_help (procedure,
@@ -4429,7 +4429,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-pattern
    */
-  procedure = gimp_procedure_new (context_get_pattern_invoker);
+  procedure = gimp_procedure_new (context_get_pattern_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-pattern");
   gimp_procedure_set_static_help (procedure,
@@ -4454,7 +4454,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-pattern
    */
-  procedure = gimp_procedure_new (context_set_pattern_invoker);
+  procedure = gimp_procedure_new (context_set_pattern_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-pattern");
   gimp_procedure_set_static_help (procedure,
@@ -4479,7 +4479,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-gradient
    */
-  procedure = gimp_procedure_new (context_get_gradient_invoker);
+  procedure = gimp_procedure_new (context_get_gradient_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-gradient");
   gimp_procedure_set_static_help (procedure,
@@ -4504,7 +4504,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-gradient
    */
-  procedure = gimp_procedure_new (context_set_gradient_invoker);
+  procedure = gimp_procedure_new (context_set_gradient_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-gradient");
   gimp_procedure_set_static_help (procedure,
@@ -4529,7 +4529,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-gradient-fg-bg-rgb
    */
-  procedure = gimp_procedure_new (context_set_gradient_fg_bg_rgb_invoker);
+  procedure = gimp_procedure_new (context_set_gradient_fg_bg_rgb_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-gradient-fg-bg-rgb");
   gimp_procedure_set_static_help (procedure,
@@ -4546,7 +4546,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-gradient-fg-bg-hsv-cw
    */
-  procedure = gimp_procedure_new (context_set_gradient_fg_bg_hsv_cw_invoker);
+  procedure = gimp_procedure_new (context_set_gradient_fg_bg_hsv_cw_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-gradient-fg-bg-hsv-cw");
   gimp_procedure_set_static_help (procedure,
@@ -4563,7 +4563,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-gradient-fg-bg-hsv-ccw
    */
-  procedure = gimp_procedure_new (context_set_gradient_fg_bg_hsv_ccw_invoker);
+  procedure = gimp_procedure_new (context_set_gradient_fg_bg_hsv_ccw_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-gradient-fg-bg-hsv-ccw");
   gimp_procedure_set_static_help (procedure,
@@ -4580,7 +4580,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-gradient-fg-transparent
    */
-  procedure = gimp_procedure_new (context_set_gradient_fg_transparent_invoker);
+  procedure = gimp_procedure_new (context_set_gradient_fg_transparent_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-gradient-fg-transparent");
   gimp_procedure_set_static_help (procedure,
@@ -4597,7 +4597,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-gradient-blend-color-space
    */
-  procedure = gimp_procedure_new (context_get_gradient_blend_color_space_invoker);
+  procedure = gimp_procedure_new (context_get_gradient_blend_color_space_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-gradient-blend-color-space");
   gimp_procedure_set_static_help (procedure,
@@ -4621,7 +4621,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-gradient-blend-color-space
    */
-  procedure = gimp_procedure_new (context_set_gradient_blend_color_space_invoker);
+  procedure = gimp_procedure_new (context_set_gradient_blend_color_space_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-gradient-blend-color-space");
   gimp_procedure_set_static_help (procedure,
@@ -4645,7 +4645,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-gradient-repeat-mode
    */
-  procedure = gimp_procedure_new (context_get_gradient_repeat_mode_invoker);
+  procedure = gimp_procedure_new (context_get_gradient_repeat_mode_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-gradient-repeat-mode");
   gimp_procedure_set_static_help (procedure,
@@ -4669,7 +4669,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-gradient-repeat-mode
    */
-  procedure = gimp_procedure_new (context_set_gradient_repeat_mode_invoker);
+  procedure = gimp_procedure_new (context_set_gradient_repeat_mode_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-gradient-repeat-mode");
   gimp_procedure_set_static_help (procedure,
@@ -4693,7 +4693,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-gradient-reverse
    */
-  procedure = gimp_procedure_new (context_get_gradient_reverse_invoker);
+  procedure = gimp_procedure_new (context_get_gradient_reverse_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-gradient-reverse");
   gimp_procedure_set_static_help (procedure,
@@ -4716,7 +4716,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-gradient-reverse
    */
-  procedure = gimp_procedure_new (context_set_gradient_reverse_invoker);
+  procedure = gimp_procedure_new (context_set_gradient_reverse_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-gradient-reverse");
   gimp_procedure_set_static_help (procedure,
@@ -4739,7 +4739,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-palette
    */
-  procedure = gimp_procedure_new (context_get_palette_invoker);
+  procedure = gimp_procedure_new (context_get_palette_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-palette");
   gimp_procedure_set_static_help (procedure,
@@ -4764,7 +4764,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-palette
    */
-  procedure = gimp_procedure_new (context_set_palette_invoker);
+  procedure = gimp_procedure_new (context_set_palette_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-palette");
   gimp_procedure_set_static_help (procedure,
@@ -4789,7 +4789,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-font
    */
-  procedure = gimp_procedure_new (context_get_font_invoker);
+  procedure = gimp_procedure_new (context_get_font_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-font");
   gimp_procedure_set_static_help (procedure,
@@ -4814,7 +4814,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-font
    */
-  procedure = gimp_procedure_new (context_set_font_invoker);
+  procedure = gimp_procedure_new (context_set_font_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-font");
   gimp_procedure_set_static_help (procedure,
@@ -4839,7 +4839,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-antialias
    */
-  procedure = gimp_procedure_new (context_get_antialias_invoker);
+  procedure = gimp_procedure_new (context_get_antialias_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-antialias");
   gimp_procedure_set_static_help (procedure,
@@ -4862,7 +4862,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-antialias
    */
-  procedure = gimp_procedure_new (context_set_antialias_invoker);
+  procedure = gimp_procedure_new (context_set_antialias_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-antialias");
   gimp_procedure_set_static_help (procedure,
@@ -4887,7 +4887,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-feather
    */
-  procedure = gimp_procedure_new (context_get_feather_invoker);
+  procedure = gimp_procedure_new (context_get_feather_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-feather");
   gimp_procedure_set_static_help (procedure,
@@ -4910,7 +4910,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-feather
    */
-  procedure = gimp_procedure_new (context_set_feather_invoker);
+  procedure = gimp_procedure_new (context_set_feather_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-feather");
   gimp_procedure_set_static_help (procedure,
@@ -4935,7 +4935,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-feather-radius
    */
-  procedure = gimp_procedure_new (context_get_feather_radius_invoker);
+  procedure = gimp_procedure_new (context_get_feather_radius_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-feather-radius");
   gimp_procedure_set_static_help (procedure,
@@ -4964,7 +4964,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-feather-radius
    */
-  procedure = gimp_procedure_new (context_set_feather_radius_invoker);
+  procedure = gimp_procedure_new (context_set_feather_radius_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-feather-radius");
   gimp_procedure_set_static_help (procedure,
@@ -4995,7 +4995,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-sample-merged
    */
-  procedure = gimp_procedure_new (context_get_sample_merged_invoker);
+  procedure = gimp_procedure_new (context_get_sample_merged_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-sample-merged");
   gimp_procedure_set_static_help (procedure,
@@ -5018,7 +5018,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-sample-merged
    */
-  procedure = gimp_procedure_new (context_set_sample_merged_invoker);
+  procedure = gimp_procedure_new (context_set_sample_merged_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-sample-merged");
   gimp_procedure_set_static_help (procedure,
@@ -5043,7 +5043,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-sample-criterion
    */
-  procedure = gimp_procedure_new (context_get_sample_criterion_invoker);
+  procedure = gimp_procedure_new (context_get_sample_criterion_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-sample-criterion");
   gimp_procedure_set_static_help (procedure,
@@ -5067,7 +5067,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-sample-criterion
    */
-  procedure = gimp_procedure_new (context_set_sample_criterion_invoker);
+  procedure = gimp_procedure_new (context_set_sample_criterion_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-sample-criterion");
   gimp_procedure_set_static_help (procedure,
@@ -5093,7 +5093,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-sample-threshold
    */
-  procedure = gimp_procedure_new (context_get_sample_threshold_invoker);
+  procedure = gimp_procedure_new (context_get_sample_threshold_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-sample-threshold");
   gimp_procedure_set_static_help (procedure,
@@ -5116,7 +5116,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-sample-threshold
    */
-  procedure = gimp_procedure_new (context_set_sample_threshold_invoker);
+  procedure = gimp_procedure_new (context_set_sample_threshold_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-sample-threshold");
   gimp_procedure_set_static_help (procedure,
@@ -5141,7 +5141,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-sample-threshold-int
    */
-  procedure = gimp_procedure_new (context_get_sample_threshold_int_invoker);
+  procedure = gimp_procedure_new (context_get_sample_threshold_int_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-sample-threshold-int");
   gimp_procedure_set_static_help (procedure,
@@ -5164,7 +5164,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-sample-threshold-int
    */
-  procedure = gimp_procedure_new (context_set_sample_threshold_int_invoker);
+  procedure = gimp_procedure_new (context_set_sample_threshold_int_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-sample-threshold-int");
   gimp_procedure_set_static_help (procedure,
@@ -5187,7 +5187,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-sample-transparent
    */
-  procedure = gimp_procedure_new (context_get_sample_transparent_invoker);
+  procedure = gimp_procedure_new (context_get_sample_transparent_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-sample-transparent");
   gimp_procedure_set_static_help (procedure,
@@ -5210,7 +5210,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-sample-transparent
    */
-  procedure = gimp_procedure_new (context_set_sample_transparent_invoker);
+  procedure = gimp_procedure_new (context_set_sample_transparent_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-sample-transparent");
   gimp_procedure_set_static_help (procedure,
@@ -5235,7 +5235,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-diagonal-neighbors
    */
-  procedure = gimp_procedure_new (context_get_diagonal_neighbors_invoker);
+  procedure = gimp_procedure_new (context_get_diagonal_neighbors_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-diagonal-neighbors");
   gimp_procedure_set_static_help (procedure,
@@ -5258,7 +5258,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-diagonal-neighbors
    */
-  procedure = gimp_procedure_new (context_set_diagonal_neighbors_invoker);
+  procedure = gimp_procedure_new (context_set_diagonal_neighbors_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-diagonal-neighbors");
   gimp_procedure_set_static_help (procedure,
@@ -5283,7 +5283,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-distance-metric
    */
-  procedure = gimp_procedure_new (context_get_distance_metric_invoker);
+  procedure = gimp_procedure_new (context_get_distance_metric_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-distance-metric");
   gimp_procedure_set_static_help (procedure,
@@ -5307,7 +5307,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-distance-metric
    */
-  procedure = gimp_procedure_new (context_set_distance_metric_invoker);
+  procedure = gimp_procedure_new (context_set_distance_metric_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-distance-metric");
   gimp_procedure_set_static_help (procedure,
@@ -5333,7 +5333,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-interpolation
    */
-  procedure = gimp_procedure_new (context_get_interpolation_invoker);
+  procedure = gimp_procedure_new (context_get_interpolation_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-interpolation");
   gimp_procedure_set_static_help (procedure,
@@ -5357,7 +5357,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-interpolation
    */
-  procedure = gimp_procedure_new (context_set_interpolation_invoker);
+  procedure = gimp_procedure_new (context_set_interpolation_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-interpolation");
   gimp_procedure_set_static_help (procedure,
@@ -5383,7 +5383,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-transform-direction
    */
-  procedure = gimp_procedure_new (context_get_transform_direction_invoker);
+  procedure = gimp_procedure_new (context_get_transform_direction_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-transform-direction");
   gimp_procedure_set_static_help (procedure,
@@ -5407,7 +5407,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-transform-direction
    */
-  procedure = gimp_procedure_new (context_set_transform_direction_invoker);
+  procedure = gimp_procedure_new (context_set_transform_direction_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-transform-direction");
   gimp_procedure_set_static_help (procedure,
@@ -5433,7 +5433,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-transform-resize
    */
-  procedure = gimp_procedure_new (context_get_transform_resize_invoker);
+  procedure = gimp_procedure_new (context_get_transform_resize_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-transform-resize");
   gimp_procedure_set_static_help (procedure,
@@ -5457,7 +5457,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-transform-resize
    */
-  procedure = gimp_procedure_new (context_set_transform_resize_invoker);
+  procedure = gimp_procedure_new (context_set_transform_resize_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-transform-resize");
   gimp_procedure_set_static_help (procedure,
@@ -5483,7 +5483,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-ink-size
    */
-  procedure = gimp_procedure_new (context_get_ink_size_invoker);
+  procedure = gimp_procedure_new (context_get_ink_size_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-ink-size");
   gimp_procedure_set_static_help (procedure,
@@ -5506,7 +5506,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-ink-size
    */
-  procedure = gimp_procedure_new (context_set_ink_size_invoker);
+  procedure = gimp_procedure_new (context_set_ink_size_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-ink-size");
   gimp_procedure_set_static_help (procedure,
@@ -5529,7 +5529,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-ink-angle
    */
-  procedure = gimp_procedure_new (context_get_ink_angle_invoker);
+  procedure = gimp_procedure_new (context_get_ink_angle_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-ink-angle");
   gimp_procedure_set_static_help (procedure,
@@ -5552,7 +5552,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-ink-angle
    */
-  procedure = gimp_procedure_new (context_set_ink_angle_invoker);
+  procedure = gimp_procedure_new (context_set_ink_angle_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-ink-angle");
   gimp_procedure_set_static_help (procedure,
@@ -5575,7 +5575,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-ink-size-sensitivity
    */
-  procedure = gimp_procedure_new (context_get_ink_size_sensitivity_invoker);
+  procedure = gimp_procedure_new (context_get_ink_size_sensitivity_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-ink-size-sensitivity");
   gimp_procedure_set_static_help (procedure,
@@ -5598,7 +5598,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-ink-size-sensitivity
    */
-  procedure = gimp_procedure_new (context_set_ink_size_sensitivity_invoker);
+  procedure = gimp_procedure_new (context_set_ink_size_sensitivity_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-ink-size-sensitivity");
   gimp_procedure_set_static_help (procedure,
@@ -5621,7 +5621,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-ink-tilt-sensitivity
    */
-  procedure = gimp_procedure_new (context_get_ink_tilt_sensitivity_invoker);
+  procedure = gimp_procedure_new (context_get_ink_tilt_sensitivity_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-ink-tilt-sensitivity");
   gimp_procedure_set_static_help (procedure,
@@ -5644,7 +5644,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-ink-tilt-sensitivity
    */
-  procedure = gimp_procedure_new (context_set_ink_tilt_sensitivity_invoker);
+  procedure = gimp_procedure_new (context_set_ink_tilt_sensitivity_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-ink-tilt-sensitivity");
   gimp_procedure_set_static_help (procedure,
@@ -5667,7 +5667,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-ink-speed-sensitivity
    */
-  procedure = gimp_procedure_new (context_get_ink_speed_sensitivity_invoker);
+  procedure = gimp_procedure_new (context_get_ink_speed_sensitivity_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-ink-speed-sensitivity");
   gimp_procedure_set_static_help (procedure,
@@ -5690,7 +5690,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-ink-speed-sensitivity
    */
-  procedure = gimp_procedure_new (context_set_ink_speed_sensitivity_invoker);
+  procedure = gimp_procedure_new (context_set_ink_speed_sensitivity_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-ink-speed-sensitivity");
   gimp_procedure_set_static_help (procedure,
@@ -5713,7 +5713,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-ink-blob-type
    */
-  procedure = gimp_procedure_new (context_get_ink_blob_type_invoker);
+  procedure = gimp_procedure_new (context_get_ink_blob_type_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-ink-blob-type");
   gimp_procedure_set_static_help (procedure,
@@ -5737,7 +5737,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-ink-blob-type
    */
-  procedure = gimp_procedure_new (context_set_ink_blob_type_invoker);
+  procedure = gimp_procedure_new (context_set_ink_blob_type_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-ink-blob-type");
   gimp_procedure_set_static_help (procedure,
@@ -5761,7 +5761,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-ink-blob-aspect-ratio
    */
-  procedure = gimp_procedure_new (context_get_ink_blob_aspect_ratio_invoker);
+  procedure = gimp_procedure_new (context_get_ink_blob_aspect_ratio_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-ink-blob-aspect-ratio");
   gimp_procedure_set_static_help (procedure,
@@ -5784,7 +5784,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-ink-blob-aspect-ratio
    */
-  procedure = gimp_procedure_new (context_set_ink_blob_aspect_ratio_invoker);
+  procedure = gimp_procedure_new (context_set_ink_blob_aspect_ratio_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-ink-blob-aspect-ratio");
   gimp_procedure_set_static_help (procedure,
@@ -5807,7 +5807,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-ink-blob-angle
    */
-  procedure = gimp_procedure_new (context_get_ink_blob_angle_invoker);
+  procedure = gimp_procedure_new (context_get_ink_blob_angle_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-ink-blob-angle");
   gimp_procedure_set_static_help (procedure,
@@ -5830,7 +5830,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-set-ink-blob-angle
    */
-  procedure = gimp_procedure_new (context_set_ink_blob_angle_invoker);
+  procedure = gimp_procedure_new (context_set_ink_blob_angle_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-set-ink-blob-angle");
   gimp_procedure_set_static_help (procedure,
@@ -5853,7 +5853,7 @@ register_context_procs (GimpPDB *pdb)
   /*
    * gimp-context-get-resource
    */
-  procedure = gimp_procedure_new (context_get_resource_invoker);
+  procedure = gimp_procedure_new (context_get_resource_invoker, TRUE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-context-get-resource");
   gimp_procedure_set_static_help (procedure,

app/pdb/debug-cmds.c

@@ -97,7 +97,7 @@ register_debug_procs (GimpPDB *pdb)
   /*
    * gimp-debug-timer-start
    */
-  procedure = gimp_procedure_new (debug_timer_start_invoker);
+  procedure = gimp_procedure_new (debug_timer_start_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-debug-timer-start");
   gimp_procedure_set_static_help (procedure,
@@ -117,7 +117,7 @@ register_debug_procs (GimpPDB *pdb)
   /*
    * gimp-debug-timer-end
    */
-  procedure = gimp_procedure_new (debug_timer_end_invoker);
+  procedure = gimp_procedure_new (debug_timer_end_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-debug-timer-end");
   gimp_procedure_set_static_help (procedure,

app/pdb/display-cmds.c

@@ -240,7 +240,7 @@ register_display_procs (GimpPDB *pdb)
   /*
    * gimp-display-id-is-valid
    */
-  procedure = gimp_procedure_new (display_id_is_valid_invoker);
+  procedure = gimp_procedure_new (display_id_is_valid_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-display-id-is-valid");
   gimp_procedure_set_static_help (procedure,
@@ -271,7 +271,7 @@ register_display_procs (GimpPDB *pdb)
   /*
    * gimp-display-new
    */
-  procedure = gimp_procedure_new (display_new_invoker);
+  procedure = gimp_procedure_new (display_new_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-display-new");
   gimp_procedure_set_static_help (procedure,
@@ -300,7 +300,7 @@ register_display_procs (GimpPDB *pdb)
   /*
    * gimp-display-delete
    */
-  procedure = gimp_procedure_new (display_delete_invoker);
+  procedure = gimp_procedure_new (display_delete_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-display-delete");
   gimp_procedure_set_static_help (procedure,
@@ -323,7 +323,7 @@ register_display_procs (GimpPDB *pdb)
   /*
    * gimp-display-get-window-handle
    */
-  procedure = gimp_procedure_new (display_get_window_handle_invoker);
+  procedure = gimp_procedure_new (display_get_window_handle_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-display-get-window-handle");
   gimp_procedure_set_static_help (procedure,
@@ -353,7 +353,7 @@ register_display_procs (GimpPDB *pdb)
   /*
    * gimp-display-present
    */
-  procedure = gimp_procedure_new (display_present_invoker);
+  procedure = gimp_procedure_new (display_present_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-display-present");
   gimp_procedure_set_static_help (procedure,
@@ -376,7 +376,7 @@ register_display_procs (GimpPDB *pdb)
   /*
    * gimp-displays-flush
    */
-  procedure = gimp_procedure_new (displays_flush_invoker);
+  procedure = gimp_procedure_new (displays_flush_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-displays-flush");
   gimp_procedure_set_static_help (procedure,
@@ -393,7 +393,7 @@ register_display_procs (GimpPDB *pdb)
   /*
    * gimp-displays-reconnect
    */
-  procedure = gimp_procedure_new (displays_reconnect_invoker);
+  procedure = gimp_procedure_new (displays_reconnect_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-displays-reconnect");
   gimp_procedure_set_static_help (procedure,

app/pdb/drawable-cmds.c

@@ -1155,7 +1155,7 @@ register_drawable_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-get-format
    */
-  procedure = gimp_procedure_new (drawable_get_format_invoker);
+  procedure = gimp_procedure_new (drawable_get_format_invoker, TRUE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-get-format");
   gimp_procedure_set_static_help (procedure,
@@ -1186,7 +1186,7 @@ register_drawable_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-get-thumbnail-format
    */
-  procedure = gimp_procedure_new (drawable_get_thumbnail_format_invoker);
+  procedure = gimp_procedure_new (drawable_get_thumbnail_format_invoker, TRUE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-get-thumbnail-format");
   gimp_procedure_set_static_help (procedure,
@@ -1217,7 +1217,7 @@ register_drawable_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-get-pixel
    */
-  procedure = gimp_procedure_new (drawable_get_pixel_invoker);
+  procedure = gimp_procedure_new (drawable_get_pixel_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-get-pixel");
   gimp_procedure_set_static_help (procedure,
@@ -1259,7 +1259,7 @@ register_drawable_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-set-pixel
    */
-  procedure = gimp_procedure_new (drawable_set_pixel_invoker);
+  procedure = gimp_procedure_new (drawable_set_pixel_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-set-pixel");
   gimp_procedure_set_static_help (procedure,
@@ -1301,7 +1301,7 @@ register_drawable_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-type
    */
-  procedure = gimp_procedure_new (drawable_type_invoker);
+  procedure = gimp_procedure_new (drawable_type_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-type");
   gimp_procedure_set_static_help (procedure,
@@ -1331,7 +1331,7 @@ register_drawable_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-type-with-alpha
    */
-  procedure = gimp_procedure_new (drawable_type_with_alpha_invoker);
+  procedure = gimp_procedure_new (drawable_type_with_alpha_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-type-with-alpha");
   gimp_procedure_set_static_help (procedure,
@@ -1367,7 +1367,7 @@ register_drawable_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-has-alpha
    */
-  procedure = gimp_procedure_new (drawable_has_alpha_invoker);
+  procedure = gimp_procedure_new (drawable_has_alpha_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-has-alpha");
   gimp_procedure_set_static_help (procedure,
@@ -1396,7 +1396,7 @@ register_drawable_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-is-rgb
    */
-  procedure = gimp_procedure_new (drawable_is_rgb_invoker);
+  procedure = gimp_procedure_new (drawable_is_rgb_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-is-rgb");
   gimp_procedure_set_static_help (procedure,
@@ -1425,7 +1425,7 @@ register_drawable_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-is-gray
    */
-  procedure = gimp_procedure_new (drawable_is_gray_invoker);
+  procedure = gimp_procedure_new (drawable_is_gray_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-is-gray");
   gimp_procedure_set_static_help (procedure,
@@ -1454,7 +1454,7 @@ register_drawable_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-is-indexed
    */
-  procedure = gimp_procedure_new (drawable_is_indexed_invoker);
+  procedure = gimp_procedure_new (drawable_is_indexed_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-is-indexed");
   gimp_procedure_set_static_help (procedure,
@@ -1483,7 +1483,7 @@ register_drawable_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-get-bpp
    */
-  procedure = gimp_procedure_new (drawable_get_bpp_invoker);
+  procedure = gimp_procedure_new (drawable_get_bpp_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-get-bpp");
   gimp_procedure_set_static_help (procedure,
@@ -1512,7 +1512,7 @@ register_drawable_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-get-width
    */
-  procedure = gimp_procedure_new (drawable_get_width_invoker);
+  procedure = gimp_procedure_new (drawable_get_width_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-get-width");
   gimp_procedure_set_static_help (procedure,
@@ -1541,7 +1541,7 @@ register_drawable_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-get-height
    */
-  procedure = gimp_procedure_new (drawable_get_height_invoker);
+  procedure = gimp_procedure_new (drawable_get_height_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-get-height");
   gimp_procedure_set_static_help (procedure,
@@ -1570,7 +1570,7 @@ register_drawable_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-get-offsets
    */
-  procedure = gimp_procedure_new (drawable_get_offsets_invoker);
+  procedure = gimp_procedure_new (drawable_get_offsets_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-get-offsets");
   gimp_procedure_set_static_help (procedure,
@@ -1605,7 +1605,7 @@ register_drawable_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-mask-bounds
    */
-  procedure = gimp_procedure_new (drawable_mask_bounds_invoker);
+  procedure = gimp_procedure_new (drawable_mask_bounds_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-mask-bounds");
   gimp_procedure_set_static_help (procedure,
@@ -1659,7 +1659,7 @@ register_drawable_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-mask-intersect
    */
-  procedure = gimp_procedure_new (drawable_mask_intersect_invoker);
+  procedure = gimp_procedure_new (drawable_mask_intersect_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-mask-intersect");
   gimp_procedure_set_static_help (procedure,
@@ -1713,7 +1713,7 @@ register_drawable_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-append-filter-private
    */
-  procedure = gimp_procedure_new (drawable_append_filter_private_invoker);
+  procedure = gimp_procedure_new (drawable_append_filter_private_invoker, TRUE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-append-filter-private");
   gimp_procedure_set_static_help (procedure,
@@ -1745,7 +1745,7 @@ register_drawable_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-merge-filter-private
    */
-  procedure = gimp_procedure_new (drawable_merge_filter_private_invoker);
+  procedure = gimp_procedure_new (drawable_merge_filter_private_invoker, TRUE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-merge-filter-private");
   gimp_procedure_set_static_help (procedure,
@@ -1777,7 +1777,7 @@ register_drawable_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-get-filters
    */
-  procedure = gimp_procedure_new (drawable_get_filters_invoker);
+  procedure = gimp_procedure_new (drawable_get_filters_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-get-filters");
   gimp_procedure_set_static_help (procedure,
@@ -1806,7 +1806,7 @@ register_drawable_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-merge-filters
    */
-  procedure = gimp_procedure_new (drawable_merge_filters_invoker);
+  procedure = gimp_procedure_new (drawable_merge_filters_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-merge-filters");
   gimp_procedure_set_static_help (procedure,
@@ -1829,7 +1829,7 @@ register_drawable_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-merge-shadow
    */
-  procedure = gimp_procedure_new (drawable_merge_shadow_invoker);
+  procedure = gimp_procedure_new (drawable_merge_shadow_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-merge-shadow");
   gimp_procedure_set_static_help (procedure,
@@ -1858,7 +1858,7 @@ register_drawable_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-free-shadow
    */
-  procedure = gimp_procedure_new (drawable_free_shadow_invoker);
+  procedure = gimp_procedure_new (drawable_free_shadow_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-free-shadow");
   gimp_procedure_set_static_help (procedure,
@@ -1881,7 +1881,7 @@ register_drawable_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-update
    */
-  procedure = gimp_procedure_new (drawable_update_invoker);
+  procedure = gimp_procedure_new (drawable_update_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-update");
   gimp_procedure_set_static_help (procedure,
@@ -1928,7 +1928,7 @@ register_drawable_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-fill
    */
-  procedure = gimp_procedure_new (drawable_fill_invoker);
+  procedure = gimp_procedure_new (drawable_fill_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-fill");
   gimp_procedure_set_static_help (procedure,
@@ -1959,7 +1959,7 @@ register_drawable_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-offset
    */
-  procedure = gimp_procedure_new (drawable_offset_invoker);
+  procedure = gimp_procedure_new (drawable_offset_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-offset");
   gimp_procedure_set_static_help (procedure,
@@ -2014,7 +2014,7 @@ register_drawable_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-thumbnail
    */
-  procedure = gimp_procedure_new (drawable_thumbnail_invoker);
+  procedure = gimp_procedure_new (drawable_thumbnail_invoker, TRUE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-thumbnail");
   gimp_procedure_set_static_help (procedure,
@@ -2073,7 +2073,7 @@ register_drawable_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-sub-thumbnail
    */
-  procedure = gimp_procedure_new (drawable_sub_thumbnail_invoker);
+  procedure = gimp_procedure_new (drawable_sub_thumbnail_invoker, TRUE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-sub-thumbnail");
   gimp_procedure_set_static_help (procedure,
@@ -2156,7 +2156,7 @@ register_drawable_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-foreground-extract
    */
-  procedure = gimp_procedure_new (drawable_foreground_extract_invoker);
+  procedure = gimp_procedure_new (drawable_foreground_extract_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-foreground-extract");
   gimp_procedure_set_static_help (procedure,

app/pdb/drawable-color-cmds.c

@@ -838,7 +838,7 @@ register_drawable_color_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-brightness-contrast
    */
-  procedure = gimp_procedure_new (drawable_brightness_contrast_invoker);
+  procedure = gimp_procedure_new (drawable_brightness_contrast_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-brightness-contrast");
   gimp_procedure_set_static_help (procedure,
@@ -873,7 +873,7 @@ register_drawable_color_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-color-balance
    */
-  procedure = gimp_procedure_new (drawable_color_balance_invoker);
+  procedure = gimp_procedure_new (drawable_color_balance_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-color-balance");
   gimp_procedure_set_static_help (procedure,
@@ -927,7 +927,7 @@ register_drawable_color_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-colorize-hsl
    */
-  procedure = gimp_procedure_new (drawable_colorize_hsl_invoker);
+  procedure = gimp_procedure_new (drawable_colorize_hsl_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-colorize-hsl");
   gimp_procedure_set_static_help (procedure,
@@ -968,7 +968,7 @@ register_drawable_color_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-curves-explicit
    */
-  procedure = gimp_procedure_new (drawable_curves_explicit_invoker);
+  procedure = gimp_procedure_new (drawable_curves_explicit_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-curves-explicit");
   gimp_procedure_set_static_help (procedure,
@@ -1003,7 +1003,7 @@ register_drawable_color_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-curves-spline
    */
-  procedure = gimp_procedure_new (drawable_curves_spline_invoker);
+  procedure = gimp_procedure_new (drawable_curves_spline_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-curves-spline");
   gimp_procedure_set_static_help (procedure,
@@ -1038,7 +1038,7 @@ register_drawable_color_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-extract-component
    */
-  procedure = gimp_procedure_new (drawable_extract_component_invoker);
+  procedure = gimp_procedure_new (drawable_extract_component_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-extract-component");
   gimp_procedure_set_static_help (procedure,
@@ -1079,7 +1079,7 @@ register_drawable_color_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-desaturate
    */
-  procedure = gimp_procedure_new (drawable_desaturate_invoker);
+  procedure = gimp_procedure_new (drawable_desaturate_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-desaturate");
   gimp_procedure_set_static_help (procedure,
@@ -1109,7 +1109,7 @@ register_drawable_color_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-equalize
    */
-  procedure = gimp_procedure_new (drawable_equalize_invoker);
+  procedure = gimp_procedure_new (drawable_equalize_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-equalize");
   gimp_procedure_set_static_help (procedure,
@@ -1138,7 +1138,7 @@ register_drawable_color_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-histogram
    */
-  procedure = gimp_procedure_new (drawable_histogram_invoker);
+  procedure = gimp_procedure_new (drawable_histogram_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-histogram");
   gimp_procedure_set_static_help (procedure,
@@ -1216,7 +1216,7 @@ register_drawable_color_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-hue-saturation
    */
-  procedure = gimp_procedure_new (drawable_hue_saturation_invoker);
+  procedure = gimp_procedure_new (drawable_hue_saturation_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-hue-saturation");
   gimp_procedure_set_static_help (procedure,
@@ -1270,7 +1270,7 @@ register_drawable_color_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-invert
    */
-  procedure = gimp_procedure_new (drawable_invert_invoker);
+  procedure = gimp_procedure_new (drawable_invert_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-invert");
   gimp_procedure_set_static_help (procedure,
@@ -1299,7 +1299,7 @@ register_drawable_color_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-levels
    */
-  procedure = gimp_procedure_new (drawable_levels_invoker);
+  procedure = gimp_procedure_new (drawable_levels_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-levels");
   gimp_procedure_set_static_help (procedure,
@@ -1371,7 +1371,7 @@ register_drawable_color_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-levels-stretch
    */
-  procedure = gimp_procedure_new (drawable_levels_stretch_invoker);
+  procedure = gimp_procedure_new (drawable_levels_stretch_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-levels-stretch");
   gimp_procedure_set_static_help (procedure,
@@ -1394,7 +1394,7 @@ register_drawable_color_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-shadows-highlights
    */
-  procedure = gimp_procedure_new (drawable_shadows_highlights_invoker);
+  procedure = gimp_procedure_new (drawable_shadows_highlights_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-shadows-highlights");
   gimp_procedure_set_static_help (procedure,
@@ -1459,7 +1459,7 @@ register_drawable_color_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-posterize
    */
-  procedure = gimp_procedure_new (drawable_posterize_invoker);
+  procedure = gimp_procedure_new (drawable_posterize_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-posterize");
   gimp_procedure_set_static_help (procedure,
@@ -1488,7 +1488,7 @@ register_drawable_color_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-threshold
    */
-  procedure = gimp_procedure_new (drawable_threshold_invoker);
+  procedure = gimp_procedure_new (drawable_threshold_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-threshold");
   gimp_procedure_set_static_help (procedure,

app/pdb/drawable-edit-cmds.c

@@ -383,7 +383,7 @@ register_drawable_edit_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-edit-clear
    */
-  procedure = gimp_procedure_new (drawable_edit_clear_invoker);
+  procedure = gimp_procedure_new (drawable_edit_clear_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-edit-clear");
   gimp_procedure_set_static_help (procedure,
@@ -408,7 +408,7 @@ register_drawable_edit_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-edit-fill
    */
-  procedure = gimp_procedure_new (drawable_edit_fill_invoker);
+  procedure = gimp_procedure_new (drawable_edit_fill_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-edit-fill");
   gimp_procedure_set_static_help (procedure,
@@ -440,7 +440,7 @@ register_drawable_edit_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-edit-bucket-fill
    */
-  procedure = gimp_procedure_new (drawable_edit_bucket_fill_invoker);
+  procedure = gimp_procedure_new (drawable_edit_bucket_fill_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-edit-bucket-fill");
   gimp_procedure_set_static_help (procedure,
@@ -485,7 +485,7 @@ register_drawable_edit_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-edit-gradient-fill
    */
-  procedure = gimp_procedure_new (drawable_edit_gradient_fill_invoker);
+  procedure = gimp_procedure_new (drawable_edit_gradient_fill_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-edit-gradient-fill");
   gimp_procedure_set_static_help (procedure,
@@ -571,7 +571,7 @@ register_drawable_edit_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-edit-stroke-selection
    */
-  procedure = gimp_procedure_new (drawable_edit_stroke_selection_invoker);
+  procedure = gimp_procedure_new (drawable_edit_stroke_selection_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-edit-stroke-selection");
   gimp_procedure_set_static_help (procedure,
@@ -596,7 +596,7 @@ register_drawable_edit_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-edit-stroke-item
    */
-  procedure = gimp_procedure_new (drawable_edit_stroke_item_invoker);
+  procedure = gimp_procedure_new (drawable_edit_stroke_item_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-edit-stroke-item");
   gimp_procedure_set_static_help (procedure,

app/pdb/drawable-filter-cmds.c

@@ -39,6 +39,8 @@
 #include "core/gimpimage-undo-push.h"
 #include "core/gimpitem.h"
 #include "core/gimpparamspecs.h"
+#include "operations/gimp-operation-config.h"
+#include "operations/gimpoperationsettings.h"
 
 #include "gimppdb.h"
 #include "gimppdberror.h"
@@ -147,6 +149,13 @@ drawable_filter_new_invoker (GimpProcedure         *procedure,
                          "operation", operation_name,
                          NULL);
           filter = gimp_drawable_filter_new (drawable, name, operation, NULL);
+          /* We don't have a libgimp function for setting the clipping
+           * behavior. I want to look further into the whole logic first.
+           * In the meantime if all API-made filters must have a single
+           * clipping behavior, I believe that not-clipping (adjusting) is
+           * the nicer default.
+           */
+          gimp_drawable_filter_set_clip (filter, FALSE);
           g_clear_object (&operation);
         }
     }
@@ -387,18 +396,46 @@ drawable_filter_get_number_arguments_invoker (GimpProcedure         *procedure,
 {
   gboolean success = TRUE;
   GimpValueArray *return_vals;
-  const gchar *operation_name;
+  GimpDrawableFilter *filter;
   gint num_args = 0;
 
-  operation_name = g_value_get_string (gimp_value_array_index (args, 0));
+  filter = g_value_get_object (gimp_value_array_index (args, 0));
 
   if (success)
     {
-      if (gegl_has_operation (operation_name))
+      GeglNode    *node;
+      const gchar *opname;
+
+      node   = gimp_drawable_filter_get_operation (filter);
+      opname = gegl_node_get_operation (node);
+
+      if (gegl_has_operation (opname))
         {
           guint n_properties;
 
-          g_free (gegl_operation_list_properties (operation_name, &n_properties));
+          if (gimp_operation_config_is_custom (gimp, opname))
+            {
+              GimpObject   *settings = NULL;
+              GObjectClass *klass;
+              GObjectClass *parent_klass;
+              guint         n_parent_properties;
+
+              gegl_node_get (node,
+                             "config", &settings,
+                             NULL);
+              klass        = G_OBJECT_GET_CLASS (settings);
+              parent_klass = G_OBJECT_CLASS (g_type_class_peek_parent (klass));
+
+              g_free (g_object_class_list_properties (parent_klass, &n_parent_properties));
+              g_free (g_object_class_list_properties (klass, &n_properties));
+              g_clear_object (&settings);
+              n_properties -= n_parent_properties;
+            }
+          else
+            {
+              g_free (gegl_operation_list_properties (opname, &n_properties));
+            }
+
           num_args = (gint) n_properties;
         }
       else
@@ -426,25 +463,49 @@ drawable_filter_get_pspec_invoker (GimpProcedure         *procedure,
 {
   gboolean success = TRUE;
   GimpValueArray *return_vals;
-  const gchar *operation_name;
+  GimpDrawableFilter *filter;
   gint arg_num;
   GParamSpec *param_spec = NULL;
 
-  operation_name = g_value_get_string (gimp_value_array_index (args, 0));
+  filter = g_value_get_object (gimp_value_array_index (args, 0));
   arg_num = g_value_get_int (gimp_value_array_index (args, 1));
 
   if (success)
     {
-      if (gegl_has_operation (operation_name))
+      GimpObject  *settings = NULL;
+      GeglNode    *node;
+      const gchar *opname;
+
+      node   = gimp_drawable_filter_get_operation (filter);
+      opname = gegl_node_get_operation (node);
+
+      if (gegl_has_operation (opname))
         {
-          GParamSpec **specs;
-          guint        n_properties;
+          GParamSpec  **specs;
+          guint         n_properties;
+          guint         n_parent_properties = 0;
 
-          specs = gegl_operation_list_properties (operation_name, &n_properties);
-
-          if (arg_num >= 0 && arg_num < n_properties)
+          if (gimp_operation_config_is_custom (gimp, opname))
             {
-              param_spec = g_param_spec_ref (specs[arg_num]);
+              GObjectClass *klass;
+              GObjectClass *parent_klass;
+
+              gegl_node_get (node,
+                             "config", &settings,
+                             NULL);
+              klass        = G_OBJECT_GET_CLASS (settings);
+              parent_klass = G_OBJECT_CLASS (g_type_class_peek_parent (klass));
+              g_free (g_object_class_list_properties (parent_klass, &n_parent_properties));
+            }
+
+          if (settings != NULL)
+            specs = g_object_class_list_properties (G_OBJECT_GET_CLASS (settings), &n_properties);
+          else
+            specs = gegl_operation_list_properties (opname, &n_properties);
+
+          if (arg_num >= 0 && n_parent_properties + arg_num < n_properties)
+            {
+              param_spec = g_param_spec_ref (specs[n_parent_properties + arg_num]);
             }
           else
             {
@@ -457,6 +518,8 @@ drawable_filter_get_pspec_invoker (GimpProcedure         *procedure,
         {
           success = FALSE;
         }
+
+      g_clear_object (&settings);
     }
 
   return_vals = gimp_procedure_get_return_values (procedure, success,
@@ -490,23 +553,50 @@ drawable_filter_get_arguments_invoker (GimpProcedure         *procedure,
       const gchar  *opname;
       GParamSpec  **specs;
       guint         n_specs;
+      guint         n_parent_properties = 0;
       GStrvBuilder *names_builder;
+      GimpObject   *settings = NULL;
 
       node   = gimp_drawable_filter_get_operation (filter);
       opname = gegl_node_get_operation (node);
 
-      specs = gegl_operation_list_properties (opname, &n_specs);
+      if (gegl_has_operation (opname) &&
+          gimp_operation_config_is_custom (gimp, opname))
+        {
+          GObjectClass *klass;
+          GObjectClass *parent_klass;
+
+          gegl_node_get (node,
+                         "config", &settings,
+                         NULL);
+          klass        = G_OBJECT_GET_CLASS (settings);
+          parent_klass = G_OBJECT_CLASS (g_type_class_peek_parent (klass));
+          g_free (g_object_class_list_properties (parent_klass, &n_parent_properties));
+        }
+
+      if (settings != NULL)
+        {
+          specs = g_object_class_list_properties (G_OBJECT_GET_CLASS (settings), &n_specs);
+          n_specs -= n_parent_properties;
+        }
+      else
+       {
+         specs = gegl_operation_list_properties (opname, &n_specs);
+       }
 
       names_builder = g_strv_builder_new ();
       values        = gimp_value_array_new (n_specs);
 
       for (gint i = 0; i < n_specs; i++)
         {
-          GParamSpec *pspec = specs[i];
+          GParamSpec *pspec = specs[n_parent_properties + i];
           GValue      value = G_VALUE_INIT;
 
           g_value_init (&value, pspec->value_type);
-          gegl_node_get_property (node, pspec->name, &value);
+          if (settings != NULL)
+            g_object_get_property (G_OBJECT (settings), pspec->name, &value);
+          else
+            gegl_node_get_property (node, pspec->name, &value);
 
           if (GEGL_IS_PARAM_SPEC_ENUM (pspec))
             {
@@ -553,6 +643,7 @@ drawable_filter_get_arguments_invoker (GimpProcedure         *procedure,
 
       g_strv_builder_unref (names_builder);
       g_free (specs);
+      g_clear_object (&settings);
     }
 
   return_vals = gimp_procedure_get_return_values (procedure, success,
@@ -609,7 +700,7 @@ register_drawable_filter_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-filter-id-is-valid
    */
-  procedure = gimp_procedure_new (drawable_filter_id_is_valid_invoker);
+  procedure = gimp_procedure_new (drawable_filter_id_is_valid_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-filter-id-is-valid");
   gimp_procedure_set_static_help (procedure,
@@ -638,7 +729,7 @@ register_drawable_filter_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-filter-new
    */
-  procedure = gimp_procedure_new (drawable_filter_new_invoker);
+  procedure = gimp_procedure_new (drawable_filter_new_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-filter-new");
   gimp_procedure_set_static_help (procedure,
@@ -683,7 +774,7 @@ register_drawable_filter_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-filter-get-name
    */
-  procedure = gimp_procedure_new (drawable_filter_get_name_invoker);
+  procedure = gimp_procedure_new (drawable_filter_get_name_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-filter-get-name");
   gimp_procedure_set_static_help (procedure,
@@ -714,7 +805,7 @@ register_drawable_filter_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-filter-get-operation-name
    */
-  procedure = gimp_procedure_new (drawable_filter_get_operation_name_invoker);
+  procedure = gimp_procedure_new (drawable_filter_get_operation_name_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-filter-get-operation-name");
   gimp_procedure_set_static_help (procedure,
@@ -744,7 +835,7 @@ register_drawable_filter_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-filter-get-visible
    */
-  procedure = gimp_procedure_new (drawable_filter_get_visible_invoker);
+  procedure = gimp_procedure_new (drawable_filter_get_visible_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-filter-get-visible");
   gimp_procedure_set_static_help (procedure,
@@ -773,7 +864,7 @@ register_drawable_filter_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-filter-set-visible
    */
-  procedure = gimp_procedure_new (drawable_filter_set_visible_invoker);
+  procedure = gimp_procedure_new (drawable_filter_set_visible_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-filter-set-visible");
   gimp_procedure_set_static_help (procedure,
@@ -803,7 +894,7 @@ register_drawable_filter_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-filter-get-opacity
    */
-  procedure = gimp_procedure_new (drawable_filter_get_opacity_invoker);
+  procedure = gimp_procedure_new (drawable_filter_get_opacity_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-filter-get-opacity");
   gimp_procedure_set_static_help (procedure,
@@ -832,7 +923,7 @@ register_drawable_filter_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-filter-get-blend-mode
    */
-  procedure = gimp_procedure_new (drawable_filter_get_blend_mode_invoker);
+  procedure = gimp_procedure_new (drawable_filter_get_blend_mode_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-filter-get-blend-mode");
   gimp_procedure_set_static_help (procedure,
@@ -862,7 +953,7 @@ register_drawable_filter_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-filter-update
    */
-  procedure = gimp_procedure_new (drawable_filter_update_invoker);
+  procedure = gimp_procedure_new (drawable_filter_update_invoker, TRUE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-filter-update");
   gimp_procedure_set_static_help (procedure,
@@ -945,7 +1036,7 @@ register_drawable_filter_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-filter-get-number-arguments
    */
-  procedure = gimp_procedure_new (drawable_filter_get_number_arguments_invoker);
+  procedure = gimp_procedure_new (drawable_filter_get_number_arguments_invoker, TRUE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-filter-get-number-arguments");
   gimp_procedure_set_static_help (procedure,
@@ -958,12 +1049,11 @@ register_drawable_filter_procs (GimpPDB *pdb)
                                          "Jehan",
                                          "2024");
   gimp_procedure_add_argument (procedure,
-                               gimp_param_spec_string ("operation-name",
-                                                       "operation name",
-                                                       "The procedure name",
-                                                       FALSE, FALSE, TRUE,
-                                                       NULL,
-                                                       GIMP_PARAM_READWRITE));
+                               gimp_param_spec_drawable_filter ("filter",
+                                                                "filter",
+                                                                "The filter",
+                                                                FALSE,
+                                                                GIMP_PARAM_READWRITE));
   gimp_procedure_add_return_value (procedure,
                                    g_param_spec_int ("num-args",
                                                      "num args",
@@ -976,7 +1066,7 @@ register_drawable_filter_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-filter-get-pspec
    */
-  procedure = gimp_procedure_new (drawable_filter_get_pspec_invoker);
+  procedure = gimp_procedure_new (drawable_filter_get_pspec_invoker, TRUE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-filter-get-pspec");
   gimp_procedure_set_static_help (procedure,
@@ -988,12 +1078,11 @@ register_drawable_filter_procs (GimpPDB *pdb)
                                          "Jehan",
                                          "2024");
   gimp_procedure_add_argument (procedure,
-                               gimp_param_spec_string ("operation-name",
-                                                       "operation name",
-                                                       "The procedure name",
-                                                       FALSE, FALSE, TRUE,
-                                                       NULL,
-                                                       GIMP_PARAM_READWRITE));
+                               gimp_param_spec_drawable_filter ("filter",
+                                                                "filter",
+                                                                "The filter",
+                                                                FALSE,
+                                                                GIMP_PARAM_READWRITE));
   gimp_procedure_add_argument (procedure,
                                g_param_spec_int ("arg-num",
                                                  "arg num",
@@ -1012,7 +1101,7 @@ register_drawable_filter_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-filter-get-arguments
    */
-  procedure = gimp_procedure_new (drawable_filter_get_arguments_invoker);
+  procedure = gimp_procedure_new (drawable_filter_get_arguments_invoker, TRUE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-filter-get-arguments");
   gimp_procedure_set_static_help (procedure,
@@ -1047,7 +1136,7 @@ register_drawable_filter_procs (GimpPDB *pdb)
   /*
    * gimp-drawable-filter-delete
    */
-  procedure = gimp_procedure_new (drawable_filter_delete_invoker);
+  procedure = gimp_procedure_new (drawable_filter_delete_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawable-filter-delete");
   gimp_procedure_set_static_help (procedure,

app/pdb/drawable-select-cmds.c

@@ -136,7 +136,7 @@ register_drawable_select_procs (GimpPDB *pdb)
   /*
    * gimp-drawables-popup
    */
-  procedure = gimp_procedure_new (drawables_popup_invoker);
+  procedure = gimp_procedure_new (drawables_popup_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawables-popup");
   gimp_procedure_set_static_help (procedure,
@@ -172,7 +172,7 @@ register_drawable_select_procs (GimpPDB *pdb)
                                gimp_param_spec_drawable ("initial-drawable",
                                                          "initial drawable",
                                                          "The drawable to set as the initial choice",
-                                                         FALSE,
+                                                         TRUE,
                                                          GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
   gimp_procedure_add_argument (procedure,
                                g_param_spec_boxed ("parent-window",
@@ -186,7 +186,7 @@ register_drawable_select_procs (GimpPDB *pdb)
   /*
    * gimp-drawables-close-popup
    */
-  procedure = gimp_procedure_new (drawables_close_popup_invoker);
+  procedure = gimp_procedure_new (drawables_close_popup_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawables-close-popup");
   gimp_procedure_set_static_help (procedure,
@@ -210,7 +210,7 @@ register_drawable_select_procs (GimpPDB *pdb)
   /*
    * gimp-drawables-set-popup
    */
-  procedure = gimp_procedure_new (drawables_set_popup_invoker);
+  procedure = gimp_procedure_new (drawables_set_popup_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-drawables-set-popup");
   gimp_procedure_set_static_help (procedure,

app/pdb/dynamics-cmds.c

@@ -91,7 +91,7 @@ register_dynamics_procs (GimpPDB *pdb)
   /*
    * gimp-dynamics-refresh
    */
-  procedure = gimp_procedure_new (dynamics_refresh_invoker);
+  procedure = gimp_procedure_new (dynamics_refresh_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-dynamics-refresh");
   gimp_procedure_set_static_help (procedure,
@@ -108,7 +108,7 @@ register_dynamics_procs (GimpPDB *pdb)
   /*
    * gimp-dynamics-get-name-list
    */
-  procedure = gimp_procedure_new (dynamics_get_name_list_invoker);
+  procedure = gimp_procedure_new (dynamics_get_name_list_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-dynamics-get-name-list");
   gimp_procedure_set_static_help (procedure,

app/pdb/edit-cmds.c

@@ -656,7 +656,7 @@ register_edit_procs (GimpPDB *pdb)
   /*
    * gimp-edit-cut
    */
-  procedure = gimp_procedure_new (edit_cut_invoker);
+  procedure = gimp_procedure_new (edit_cut_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-edit-cut");
   gimp_procedure_set_static_help (procedure,
@@ -686,7 +686,7 @@ register_edit_procs (GimpPDB *pdb)
   /*
    * gimp-edit-copy
    */
-  procedure = gimp_procedure_new (edit_copy_invoker);
+  procedure = gimp_procedure_new (edit_copy_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-edit-copy");
   gimp_procedure_set_static_help (procedure,
@@ -717,7 +717,7 @@ register_edit_procs (GimpPDB *pdb)
   /*
    * gimp-edit-copy-visible
    */
-  procedure = gimp_procedure_new (edit_copy_visible_invoker);
+  procedure = gimp_procedure_new (edit_copy_visible_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-edit-copy-visible");
   gimp_procedure_set_static_help (procedure,
@@ -746,7 +746,7 @@ register_edit_procs (GimpPDB *pdb)
   /*
    * gimp-edit-paste
    */
-  procedure = gimp_procedure_new (edit_paste_invoker);
+  procedure = gimp_procedure_new (edit_paste_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-edit-paste");
   gimp_procedure_set_static_help (procedure,
@@ -782,7 +782,7 @@ register_edit_procs (GimpPDB *pdb)
   /*
    * gimp-edit-paste-as-new-image
    */
-  procedure = gimp_procedure_new (edit_paste_as_new_image_invoker);
+  procedure = gimp_procedure_new (edit_paste_as_new_image_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-edit-paste-as-new-image");
   gimp_procedure_set_static_help (procedure,
@@ -805,7 +805,7 @@ register_edit_procs (GimpPDB *pdb)
   /*
    * gimp-edit-named-cut
    */
-  procedure = gimp_procedure_new (edit_named_cut_invoker);
+  procedure = gimp_procedure_new (edit_named_cut_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-edit-named-cut");
   gimp_procedure_set_static_help (procedure,
@@ -842,7 +842,7 @@ register_edit_procs (GimpPDB *pdb)
   /*
    * gimp-edit-named-copy
    */
-  procedure = gimp_procedure_new (edit_named_copy_invoker);
+  procedure = gimp_procedure_new (edit_named_copy_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-edit-named-copy");
   gimp_procedure_set_static_help (procedure,
@@ -879,7 +879,7 @@ register_edit_procs (GimpPDB *pdb)
   /*
    * gimp-edit-named-copy-visible
    */
-  procedure = gimp_procedure_new (edit_named_copy_visible_invoker);
+  procedure = gimp_procedure_new (edit_named_copy_visible_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-edit-named-copy-visible");
   gimp_procedure_set_static_help (procedure,
@@ -916,7 +916,7 @@ register_edit_procs (GimpPDB *pdb)
   /*
    * gimp-edit-named-paste
    */
-  procedure = gimp_procedure_new (edit_named_paste_invoker);
+  procedure = gimp_procedure_new (edit_named_paste_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-edit-named-paste");
   gimp_procedure_set_static_help (procedure,
@@ -958,7 +958,7 @@ register_edit_procs (GimpPDB *pdb)
   /*
    * gimp-edit-named-paste-as-new-image
    */
-  procedure = gimp_procedure_new (edit_named_paste_as_new_image_invoker);
+  procedure = gimp_procedure_new (edit_named_paste_as_new_image_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-edit-named-paste-as-new-image");
   gimp_procedure_set_static_help (procedure,

app/pdb/file-cmds.c

@@ -338,12 +338,12 @@ file_load_thumbnail_invoker (GimpProcedure         *procedure,
 }
 
 static GimpValueArray *
-file_save_thumbnail_invoker (GimpProcedure         *procedure,
-                             Gimp                  *gimp,
-                             GimpContext           *context,
-                             GimpProgress          *progress,
-                             const GimpValueArray  *args,
-                             GError               **error)
+file_create_thumbnail_invoker (GimpProcedure         *procedure,
+                               Gimp                  *gimp,
+                               GimpContext           *context,
+                               GimpProgress          *progress,
+                               const GimpValueArray  *args,
+                               GError               **error)
 {
   gboolean success = TRUE;
   GimpImage *image;
@@ -369,7 +369,7 @@ register_file_procs (GimpPDB *pdb)
   /*
    * gimp-file-load
    */
-  procedure = gimp_procedure_new (file_load_invoker);
+  procedure = gimp_procedure_new (file_load_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-file-load");
   gimp_procedure_set_static_help (procedure,
@@ -407,7 +407,7 @@ register_file_procs (GimpPDB *pdb)
   /*
    * gimp-file-load-layer
    */
-  procedure = gimp_procedure_new (file_load_layer_invoker);
+  procedure = gimp_procedure_new (file_load_layer_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-file-load-layer");
   gimp_procedure_set_static_help (procedure,
@@ -451,7 +451,7 @@ register_file_procs (GimpPDB *pdb)
   /*
    * gimp-file-load-layers
    */
-  procedure = gimp_procedure_new (file_load_layers_invoker);
+  procedure = gimp_procedure_new (file_load_layers_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-file-load-layers");
   gimp_procedure_set_static_help (procedure,
@@ -495,12 +495,13 @@ register_file_procs (GimpPDB *pdb)
   /*
    * gimp-file-save
    */
-  procedure = gimp_procedure_new (file_save_invoker);
+  procedure = gimp_procedure_new (file_save_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-file-save");
   gimp_procedure_set_static_help (procedure,
-                                  "Saves a file by extension.",
-                                  "This procedure invokes the correct file save handler according to the file's extension and/or prefix.\n"
+                                  "Saves to XCF or export @image to any supported format by extension.",
+                                  "This procedure invokes the correct file save/export handler according to @file's extension and/or prefix.\n"
+                                  "\n"
                                   "The @options argument is currently unused and should be set to %NULL right now.",
                                   NULL);
   gimp_procedure_set_static_attribution (procedure,
@@ -523,7 +524,7 @@ register_file_procs (GimpPDB *pdb)
   gimp_procedure_add_argument (procedure,
                                g_param_spec_object ("file",
                                                     "file",
-                                                    "The file to save the image in",
+                                                    "The file to save or export the image in",
                                                     G_TYPE_FILE,
                                                     GIMP_PARAM_READWRITE));
   gimp_procedure_add_argument (procedure,
@@ -537,7 +538,7 @@ register_file_procs (GimpPDB *pdb)
   /*
    * gimp-file-load-thumbnail
    */
-  procedure = gimp_procedure_new (file_load_thumbnail_invoker);
+  procedure = gimp_procedure_new (file_load_thumbnail_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-file-load-thumbnail");
   gimp_procedure_set_static_help (procedure,
@@ -576,14 +577,17 @@ register_file_procs (GimpPDB *pdb)
   g_object_unref (procedure);
 
   /*
-   * gimp-file-save-thumbnail
+   * gimp-file-create-thumbnail
    */
-  procedure = gimp_procedure_new (file_save_thumbnail_invoker);
+  procedure = gimp_procedure_new (file_create_thumbnail_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
-                               "gimp-file-save-thumbnail");
+                               "gimp-file-create-thumbnail");
   gimp_procedure_set_static_help (procedure,
-                                  "Saves a thumbnail for the given image",
-                                  "This procedure saves a thumbnail for the given image according to the Free Desktop Thumbnail Managing Standard. The thumbnail is saved so that it belongs to the given file. This means you have to save the image under this name first, otherwise this procedure will fail. This procedure may become useful if you want to explicitly save a thumbnail with a file.",
+                                  "Creates a thumbnail of @image for the given @file",
+                                  "This procedure creates a thumbnail for the given @file and stores it according to relevant standards.\n"
+                                  "In particular, it will follow the [Free Desktop Thumbnail Managing Standard](https://specifications.freedesktop.org/thumbnail-spec/latest/thumbsave.html) when relevant.\n"
+                                  "\n"
+                                  "The thumbnail is stored so that it belongs to the given @file. This means you have to save @image under this name first. As a fallback, the call will work if @image was exported or imported as @file. In any other case, this procedure will fail.",
                                   NULL);
   gimp_procedure_set_static_attribution (procedure,
                                          "Josh MacDonald",

app/pdb/floating-sel-cmds.c

@@ -188,7 +188,7 @@ register_floating_sel_procs (GimpPDB *pdb)
   /*
    * gimp-floating-sel-remove
    */
-  procedure = gimp_procedure_new (floating_sel_remove_invoker);
+  procedure = gimp_procedure_new (floating_sel_remove_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-floating-sel-remove");
   gimp_procedure_set_static_help (procedure,
@@ -211,7 +211,7 @@ register_floating_sel_procs (GimpPDB *pdb)
   /*
    * gimp-floating-sel-anchor
    */
-  procedure = gimp_procedure_new (floating_sel_anchor_invoker);
+  procedure = gimp_procedure_new (floating_sel_anchor_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-floating-sel-anchor");
   gimp_procedure_set_static_help (procedure,
@@ -234,7 +234,7 @@ register_floating_sel_procs (GimpPDB *pdb)
   /*
    * gimp-floating-sel-to-layer
    */
-  procedure = gimp_procedure_new (floating_sel_to_layer_invoker);
+  procedure = gimp_procedure_new (floating_sel_to_layer_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-floating-sel-to-layer");
   gimp_procedure_set_static_help (procedure,
@@ -257,7 +257,7 @@ register_floating_sel_procs (GimpPDB *pdb)
   /*
    * gimp-floating-sel-attach
    */
-  procedure = gimp_procedure_new (floating_sel_attach_invoker);
+  procedure = gimp_procedure_new (floating_sel_attach_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-floating-sel-attach");
   gimp_procedure_set_static_help (procedure,

app/pdb/font-cmds.c

@@ -107,7 +107,7 @@ register_font_procs (GimpPDB *pdb)
   /*
    * gimp-font-get-lookup-name
    */
-  procedure = gimp_procedure_new (font_get_lookup_name_invoker);
+  procedure = gimp_procedure_new (font_get_lookup_name_invoker, TRUE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-font-get-lookup-name");
   gimp_procedure_set_static_help (procedure,
@@ -139,7 +139,7 @@ register_font_procs (GimpPDB *pdb)
   /*
    * gimp-font-get-by-name
    */
-  procedure = gimp_procedure_new (font_get_by_name_invoker);
+  procedure = gimp_procedure_new (font_get_by_name_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-font-get-by-name");
   gimp_procedure_set_static_help (procedure,

app/pdb/font-select-cmds.c

@@ -146,7 +146,7 @@ register_font_select_procs (GimpPDB *pdb)
   /*
    * gimp-fonts-popup
    */
-  procedure = gimp_procedure_new (fonts_popup_invoker);
+  procedure = gimp_procedure_new (fonts_popup_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-fonts-popup");
   gimp_procedure_set_static_help (procedure,
@@ -175,7 +175,7 @@ register_font_select_procs (GimpPDB *pdb)
                                gimp_param_spec_font ("initial-font",
                                                      "initial font",
                                                      "The name of the initial font choice.",
-                                                     FALSE,
+                                                     TRUE,
                                                      NULL,
                                                      FALSE,
                                                      GIMP_PARAM_READWRITE));
@@ -191,7 +191,7 @@ register_font_select_procs (GimpPDB *pdb)
   /*
    * gimp-fonts-close-popup
    */
-  procedure = gimp_procedure_new (fonts_close_popup_invoker);
+  procedure = gimp_procedure_new (fonts_close_popup_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-fonts-close-popup");
   gimp_procedure_set_static_help (procedure,
@@ -215,7 +215,7 @@ register_font_select_procs (GimpPDB *pdb)
   /*
    * gimp-fonts-set-popup
    */
-  procedure = gimp_procedure_new (fonts_set_popup_invoker);
+  procedure = gimp_procedure_new (fonts_set_popup_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-fonts-set-popup");
   gimp_procedure_set_static_help (procedure,

app/pdb/fonts-cmds.c

@@ -152,7 +152,7 @@ register_fonts_procs (GimpPDB *pdb)
   /*
    * gimp-fonts-refresh
    */
-  procedure = gimp_procedure_new (fonts_refresh_invoker);
+  procedure = gimp_procedure_new (fonts_refresh_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-fonts-refresh");
   gimp_procedure_set_static_help (procedure,
@@ -169,7 +169,7 @@ register_fonts_procs (GimpPDB *pdb)
   /*
    * gimp-fonts-get-custom-configs
    */
-  procedure = gimp_procedure_new (fonts_get_custom_configs_invoker);
+  procedure = gimp_procedure_new (fonts_get_custom_configs_invoker, TRUE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-fonts-get-custom-configs");
   gimp_procedure_set_static_help (procedure,
@@ -213,7 +213,7 @@ register_fonts_procs (GimpPDB *pdb)
   /*
    * gimp-fonts-get-list
    */
-  procedure = gimp_procedure_new (fonts_get_list_invoker);
+  procedure = gimp_procedure_new (fonts_get_list_invoker, FALSE);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
                                "gimp-fonts-get-list");
   gimp_procedure_set_static_help (procedure,