Adjusting of Deprecation Handling of Options

diff --git a/MagickCore/option.c b/MagickCore/option.c
index e5b4c617738db6ac509b088ca6c1e5ec48435d41..98465c048d61c8a44981a9e8fa01af1267972147 100644 (file)
--- a/MagickCore/option.c
+++ b/MagickCore/option.c
@@ -192,8 +192,8 @@ static const OptionInfo
     { "-adaptive-sharpen", 1L, SimpleOperatorOptionFlag, MagickFalse },
     { "+adjoin", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-adjoin", 0L, ImageInfoOptionFlag, MagickFalse },
-    { "+affine", 0L, DeprecateOptionFlag | DrawInfoOptionFlag, MagickTrue },
-    { "-affine", 1L, DeprecateOptionFlag | DrawInfoOptionFlag, MagickTrue },
+    { "+affine", 0L, ReplacedOptionFlag | DrawInfoOptionFlag, MagickTrue },
+    { "-affine", 1L, ReplacedOptionFlag | DrawInfoOptionFlag, MagickTrue },
     { "+affinity", 0L, DeprecateOptionFlag, MagickTrue },
     { "-affinity", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
     { "+alpha", 1L, DeprecateOptionFlag, MagickTrue },
@@ -214,8 +214,8 @@ static const OptionInfo
     { "-auto-level", 0L, SimpleOperatorOptionFlag, MagickFalse },
     { "+auto-orient", 0L, DeprecateOptionFlag, MagickTrue },
     { "-auto-orient", 0L, SimpleOperatorOptionFlag, MagickFalse },
-    { "+average", 0L, DeprecateOptionFlag | ListOperatorOptionFlag | FireOptionFlag, MagickTrue },
-    { "-average", 0L, DeprecateOptionFlag | ListOperatorOptionFlag | FireOptionFlag, MagickTrue },
+    { "+average", 0L, DeprecateOptionFlag, MagickTrue },
+    { "-average", 0L, ReplacedOptionFlag | ListOperatorOptionFlag | FireOptionFlag, MagickTrue },
     { "+backdrop", 0L, NonMagickOptionFlag, MagickFalse },
     { "-backdrop", 1L, NonMagickOptionFlag, MagickFalse },
     { "+background", 0L, ImageInfoOptionFlag, MagickFalse },
@@ -242,8 +242,8 @@ static const OptionInfo
     { "-bordercolor", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
     { "+borderwidth", 0L, NonMagickOptionFlag, MagickFalse },
     { "-borderwidth", 1L, NonMagickOptionFlag, MagickFalse },
-    { "+box", 0L, DeprecateOptionFlag | ImageInfoOptionFlag | DrawInfoOptionFlag, MagickTrue },
-    { "-box", 1L, DeprecateOptionFlag | ImageInfoOptionFlag | DrawInfoOptionFlag, MagickTrue },
+    { "+box", 0L, ReplacedOptionFlag | ImageInfoOptionFlag | DrawInfoOptionFlag, MagickTrue },
+    { "-box", 1L, ReplacedOptionFlag | ImageInfoOptionFlag | DrawInfoOptionFlag, MagickTrue },
     { "+brightness-contrast", 0L, DeprecateOptionFlag, MagickTrue },
     { "-brightness-contrast", 1L, SimpleOperatorOptionFlag, MagickFalse },
     { "+cache", 0L, GlobalOptionFlag, MagickFalse },
@@ -295,8 +295,8 @@ static const OptionInfo
     { "-compress", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+concurrent", 0L, DeprecateOptionFlag, MagickTrue },
     { "-concurrent", 0L, GenesisOptionFlag, MagickFalse },
-    { "+contrast", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-contrast", 0L, DeprecateOptionFlag, MagickTrue },
+    { "+contrast", 0L, ReplacedOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
+    { "-contrast", 0L, ReplacedOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
     { "+contrast-stretch", 1L, DeprecateOptionFlag, MagickTrue },
     { "-contrast-stretch", 1L, SimpleOperatorOptionFlag, MagickFalse },
     { "+convolve", 1L, DeprecateOptionFlag, MagickTrue },
@@ -310,7 +310,7 @@ static const OptionInfo
     { "+decipher", 1L, DeprecateOptionFlag, MagickTrue },
     { "-decipher", 1L, SimpleOperatorOptionFlag, MagickFalse },
     { "+deconstruct", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-deconstruct", 0L, DeprecateOptionFlag | ListOperatorOptionFlag | FireOptionFlag, MagickTrue },
+    { "-deconstruct", 0L, ReplacedOptionFlag | ListOperatorOptionFlag | FireOptionFlag, MagickTrue },
     { "+define", 1L, ImageInfoOptionFlag, MagickFalse },
     { "-define", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+delay", 0L, ImageInfoOptionFlag, MagickFalse },
@@ -405,7 +405,7 @@ static const OptionInfo
     { "+gamma", 0L, SimpleOperatorOptionFlag, MagickFalse },
     { "-gamma", 1L, SimpleOperatorOptionFlag, MagickFalse },
     { "+gaussian", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-gaussian", 1L, DeprecateOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
+    { "-gaussian", 1L, ReplacedOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
     { "+gaussian-blur", 1L, DeprecateOptionFlag, MagickTrue },
     { "-gaussian-blur", 1L, SimpleOperatorOptionFlag, MagickFalse },
     { "+geometry", 0L, SimpleOperatorOptionFlag, MagickFalse },
@@ -468,28 +468,28 @@ static const OptionInfo
     { "-log", 1L, GlobalOptionFlag, MagickFalse },
     { "+loop", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-loop", 1L, ImageInfoOptionFlag, MagickFalse },
-    { "+lowlight-color", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-lowlight-color", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "+lowlight-color", 1L, ImageInfoOptionFlag, MagickFalse },
+    { "-lowlight-color", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+magnify", 0L, NonMagickOptionFlag, MagickFalse },
     { "-magnify", 1L, NonMagickOptionFlag, MagickFalse },
-    { "+map", 0L, DeprecateOptionFlag | ListOperatorOptionFlag | FireOptionFlag, MagickTrue },
-    { "-map", 1L, DeprecateOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
+    { "+map", 0L, ReplacedOptionFlag | ListOperatorOptionFlag | FireOptionFlag, MagickTrue },
+    { "-map", 1L, ReplacedOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
     { "+mask", 0L, SimpleOperatorOptionFlag, MagickFalse },
     { "-mask", 1L, SimpleOperatorOptionFlag, MagickFalse },
-    { "+matte", 0L, DeprecateOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
-    { "-matte", 0L, DeprecateOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
+    { "+matte", 0L, ReplacedOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
+    { "-matte", 0L, ReplacedOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
     { "+mattecolor", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-mattecolor", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+maximum", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
     { "-maximum", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
     { "+median", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-median", 1L, DeprecateOptionFlag | SimpleOperatorOptionFlag | FireOptionFlag, MagickTrue },
+    { "-median", 1L, ReplacedOptionFlag | SimpleOperatorOptionFlag | FireOptionFlag, MagickTrue },
     { "+metric", 0L, NonMagickOptionFlag, MagickFalse },
     { "-metric", 1L, NonMagickOptionFlag, MagickFalse },
     { "+minimum", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
     { "-minimum", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
     { "+mode", 1L, NonMagickOptionFlag, MagickFalse },
-    { "-mode", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-mode", 1L, ReplacedOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
     { "+modulate", 1L, DeprecateOptionFlag, MagickTrue },
     { "-modulate", 1L, SimpleOperatorOptionFlag, MagickFalse },
     { "+monitor", 0L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
@@ -509,7 +509,7 @@ static const OptionInfo
     { "+negate", 0L, SimpleOperatorOptionFlag, MagickFalse },
     { "-negate", 0L, SimpleOperatorOptionFlag, MagickFalse },
     { "+noise", 1L, SimpleOperatorOptionFlag, MagickFalse },
-    { "-noise", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-noise", 1L, ReplacedOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
     { "-noop", 0L, SpecialOptionFlag, MagickFalse },
     { "+normalize", 0L, DeprecateOptionFlag, MagickTrue },
     { "-normalize", 0L, SimpleOperatorOptionFlag, MagickFalse },
@@ -519,8 +519,6 @@ static const OptionInfo
     { "-ordered-dither", 1L, SimpleOperatorOptionFlag, MagickFalse },
     { "+orient", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-orient", 1L, ImageInfoOptionFlag, MagickFalse },
-    { "+origin", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-origin", 1L, DeprecateOptionFlag, MagickTrue },
     { "+page", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-page", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+paint", 0L, DeprecateOptionFlag, MagickTrue },
@@ -561,7 +559,7 @@ static const OptionInfo
     { "-random-threshold", 1L, SimpleOperatorOptionFlag, MagickFalse },
     { "-read", 1L, SpecialOptionFlag, MagickFalse },
     { "+recolor", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-recolor", 1L, DeprecateOptionFlag, MagickTrue },
+    { "-recolor", 1L, ReplacedOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
     { "+red-primary", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-red-primary", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+regard-warnings", 0L, ImageInfoOptionFlag, MagickFalse },
@@ -694,7 +692,7 @@ static const OptionInfo
     { "+title", 0L, NonMagickOptionFlag, MagickFalse },
     { "-title", 1L, NonMagickOptionFlag, MagickFalse },
     { "+transform", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-transform", 0L, DeprecateOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
+    { "-transform", 0L, ReplacedOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
     { "+transparent", 1L, SimpleOperatorOptionFlag, MagickFalse },
     { "-transparent", 1L, SimpleOperatorOptionFlag, MagickFalse },
     { "+transparent-color", 1L, ImageInfoOptionFlag, MagickFalse },
@@ -1526,7 +1524,7 @@ static const OptionInfo
     { "Median", MedianStatistic, UndefinedOptionFlag, MagickFalse },
     { "Minimum", MinimumStatistic, UndefinedOptionFlag, MagickFalse },
     { "Mode", ModeStatistic, UndefinedOptionFlag, MagickFalse },
-    { "Nonpeak", NonpeakStatistic, UndefinedOptionFlag, MagickFalse },
+    { "NonPeak", NonpeakStatistic, UndefinedOptionFlag, MagickFalse },
     { "StandardDeviation", StandardDeviationStatistic, UndefinedOptionFlag, MagickFalse },
     { (char *) NULL, UndefinedMethod, UndefinedOptionFlag, MagickFalse }
   },

diff --git a/MagickCore/option.h b/MagickCore/option.h
index f7c541cbf4acae8d5c7b039ad9f4c446007934ff..3679bf0c1e308a60d5bbe3273cccc20ec7a625b5 100644 (file)
--- a/MagickCore/option.h
+++ b/MagickCore/option.h
@@ -148,8 +148,9 @@ typedef enum
   ImageRequiredFlags        = 0x0030,  /* Flags also means Images Required */
 
   NonMagickOptionFlag       = 0x1000,  /* Option not used by Magick Command */
-  FireOptionFlag            = 0x4000,  /* Convert operation seq firing point */
-  DeprecateOptionFlag       = 0x8000   /* Deprecate option, give warning */
+  FireOptionFlag            = 0x2000,  /* Convert operation seq firing point */
+  DeprecateOptionFlag       = 0x4000,  /* Deprecate option (no code) */
+  ReplacedOptionFlag        = 0x8000   /* Replaced Option (still works) */
 
 } CommandOptionFlags;
 

diff --git a/MagickWand/magick-cli.c b/MagickWand/magick-cli.c
index 8cf81845c27189c781885e2e0a91a754f804df58..1c2a969bb7630eb9b270f3193eb4d1c286521249 100644 (file)
--- a/MagickWand/magick-cli.c
+++ b/MagickWand/magick-cli.c
@@ -516,12 +516,8 @@ WandExport int ProcessCommandOptions(MagickCLI *cli_wand, int argc,
 #endif
 
     if ( (option_type & DeprecateOptionFlag) != 0 ) {
-      if ( (cli_wand->process_flags & ProcessReportDepreciated) != 0 ) {
-        CLIWandException(OptionWarning,"DeprecatedOption",option);
-        if ( CLICatchException(cli_wand, MagickFalse) != MagickFalse )
-          return(end);
-        /* fall through - do the depreciated option */
-      }
+      CLIWandException(OptionError,"DeprecatedOptionNoCode",option);
+      goto next_argument;
     }
     if ( (option_type & GenesisOptionFlag) != 0 ) {
       goto next_argument;  /* ignore MagickCommandGenesis() Only Option */

diff --git a/MagickWand/operation.c b/MagickWand/operation.c
index 65982cb716501a09dc8cc79273e730762e2cdfb7..e904e03ce3693951f1d8ff6e36773a0cd3644d83 100644 (file)
--- a/MagickWand/operation.c
+++ b/MagickWand/operation.c
@@ -466,7 +466,7 @@ WandExport void CLISettingOptionInfo(MagickCLI *cli_wand,
         }
       if (LocaleCompare("affine",option+1) == 0)
         {
-          /* DEPRECIATED: _draw_info setting only: for -draw and -transform */
+          CLIWandWarnDepreciated("-draw 'affine ...'");
           if (IfSetOption)
             (void) ParseAffineGeometry(arg1,&_draw_info->affine,_exception);
           else
@@ -572,8 +572,8 @@ WandExport void CLISettingOptionInfo(MagickCLI *cli_wand,
         }
       if (LocaleCompare("box",option+1) == 0)
         {
-          /* DEPRECIATED - now "undercolor" */
-          CLISettingOptionInfo(cli_wand,"undercolor",arg1, arg2);
+          CLIWandWarnDepreciated("-undercolor");
+          CLISettingOptionInfo(cli_wand,"-undercolor",arg1, arg2);
           break;
         }
       CLIWandExceptionBreak(OptionError,"UnrecognizedOption",option);
@@ -1032,6 +1032,11 @@ WandExport void CLISettingOptionInfo(MagickCLI *cli_wand,
           }
           break;
         }
+      if (LocaleCompare("lowlight-color",option+1) == 0)
+        {
+          (void) SetImageOption(_image_info,option+1,ArgOption(NULL));
+          break;
+        }
       if (LocaleCompare("loop",option+1) == 0)
         {
           /* SyncImageSettings() used to set per-image attribute. */
@@ -2036,7 +2041,7 @@ static void CLISimpleOperatorImage(MagickCLI *cli_wand,
         }
       if (LocaleCompare("contrast",option+1) == 0)
         {
-          /* DEPRECIATED: The -/+level provides far more controlled form */
+          CLIWandWarnDepreciated(normal_op?"-level":"+level");
           (void) ContrastImage(_image,normal_op,_exception);
           break;
         }
@@ -2451,8 +2456,7 @@ static void CLISimpleOperatorImage(MagickCLI *cli_wand,
             _image->gamma=StringToDouble(arg1,(char **) NULL);
           break;
         }
-      if ((LocaleCompare("gaussian-blur",option+1) == 0) ||
-          (LocaleCompare("gaussian",option+1) == 0))
+      if (LocaleCompare("gaussian-blur",option+1) == 0)
         {
           if (IfMagickFalse(IsGeometry(arg1)))
             CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
@@ -2463,6 +2467,11 @@ static void CLISimpleOperatorImage(MagickCLI *cli_wand,
             geometry_info.sigma,_exception);
           break;
         }
+      if (LocaleCompare("gaussian",option+1) == 0)
+        {
+          CLIWandWarnDepreciated("-gaussian-blur");
+          CLISimpleOperatorImage(cli_wand,"-gaussian-blur",arg1,NULL);
+        }
       if (LocaleCompare("geometry",option+1) == 0)
         {
           /*
@@ -2670,26 +2679,14 @@ static void CLISimpleOperatorImage(MagickCLI *cli_wand,
             geometry.height,1.0*geometry.x,1.0*geometry.y,_exception);
           break;
         }
-      if (LocaleCompare("lowlight-color",option+1) == 0)
-        {
-          (void) SetImageArtifact(_image,option+1,arg1);
-          break;
-        }
       CLIWandExceptionBreak(OptionError,"UnrecognizedOption",option);
     }
     case 'm':
     {
       if (LocaleCompare("map",option+1) == 0)
         {
-          Image
-            *remap_image;
-
-          /* DEPRECIATED use -remap */
-          remap_image=GetImageCache(_image_info,arg1,_exception);
-          if (remap_image == (Image *) NULL)
-            break;
-          (void) RemapImage(_quantize_info,_image,remap_image,_exception);
-          remap_image=DestroyImage(remap_image);
+          CLIWandWarnDepreciated("-remap");
+          CLISimpleOperatorImage(cli_wand,"-remap",NULL,NULL);
           break;
         }
       if (LocaleCompare("mask",option+1) == 0)
@@ -2712,28 +2709,22 @@ static void CLISimpleOperatorImage(MagickCLI *cli_wand,
         }
       if (LocaleCompare("matte",option+1) == 0)
         {
-          /* DEPRECIATED */
+          CLIWandWarnDepreciated(IfNormalOp?"-alpha Set":"-alpha Off");
           (void) SetImageAlphaChannel(_image,IfNormalOp ? SetAlphaChannel :
                          DeactivateAlphaChannel, _exception);
           break;
         }
       if (LocaleCompare("median",option+1) == 0)
         {
-          /* DEPRECIATED - use -statistic Median */
-          if (IfMagickFalse(IsGeometry(arg1)))
-            CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
+          CLIWandWarnDepreciated("-statistic Median");
           CLISimpleOperatorImage(cli_wand,"-statistic","Median",arg1);
           break;
         }
       if (LocaleCompare("mode",option+1) == 0)
         {
-          if (IfMagickFalse(IsGeometry(arg1)))
-            CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
-          flags=ParseGeometry(arg1,&geometry_info);
-          if ((flags & SigmaValue) == 0)
-            geometry_info.sigma=geometry_info.rho;
-          new_image=StatisticImage(_image,ModeStatistic,(size_t)
-            geometry_info.rho,(size_t) geometry_info.sigma,_exception);
+          /* FUTURE: note this is also a special "montage" option */
+          CLIWandWarnDepreciated("-statistic Mode");
+          CLISimpleOperatorImage(cli_wand,"-statistic","Mode",arg1);
           break;
         }
       if (LocaleCompare("modulate",option+1) == 0)
@@ -2811,37 +2802,28 @@ static void CLISimpleOperatorImage(MagickCLI *cli_wand,
         }
       if (LocaleCompare("noise",option+1) == 0)
         {
-          if (IfNormalOp)
-            {
-              if (IfMagickFalse(IsGeometry(arg1)))
-                CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
-              flags=ParseGeometry(arg1,&geometry_info);
-              if ((flags & SigmaValue) == 0)
-                geometry_info.sigma=geometry_info.rho;
-              new_image=StatisticImage(_image,NonpeakStatistic,(size_t)
-                geometry_info.rho,(size_t) geometry_info.sigma,_exception);
-            }
-          else
-            {
-              double
-                attenuate;
-
-              const char*
-                value;
+          double
+            attenuate;
 
-              parse=ParseCommandOption(MagickNoiseOptions,MagickFalse,arg1);
-              if ( parse < 0 )
-                CLIWandExceptArgBreak(OptionError,"UnrecognizedNoiseType",
-                    option,arg1);
-              value=GetImageOption(_image_info,"attenuate");
-              if  (value != (const char *) NULL)
-                attenuate=StringToDouble(value,(char **) NULL);
-              else
-                attenuate=1.0;
+          const char*
+            value;
 
-              new_image=AddNoiseImage(_image,(NoiseType)parse,attenuate,
-                   _exception);
+          if (IfNormalOp)
+            {
+              CLIWandWarnDepreciated("-statistic NonPeak");
+              CLISimpleOperatorImage(cli_wand,"-statistic","NonPeak",arg1);
+              break;
             }
+          parse=ParseCommandOption(MagickNoiseOptions,MagickFalse,arg1);
+          if ( parse < 0 )
+            CLIWandExceptArgBreak(OptionError,"UnrecognizedNoiseType",
+                option,arg1);
+          attenuate=1.0;
+          value=GetImageOption(_image_info,"attenuate");
+          if  (value != (const char *) NULL)
+            attenuate=StringToDouble(value,(char **) NULL);
+          new_image=AddNoiseImage(_image,(NoiseType)parse,attenuate,
+               _exception);
           break;
         }
       if (LocaleCompare("normalize",option+1) == 0)
@@ -3016,6 +2998,11 @@ static void CLISimpleOperatorImage(MagickCLI *cli_wand,
           (void) RandomThresholdImage(_image,arg1,_exception);
           break;
         }
+      if (LocaleCompare("recolor",option+1) == 0)
+        {
+          CLIWandWarnDepreciated("-color-matrix");
+          CLISimpleOperatorImage(cli_wand,"-color-matrix",arg1,NULL);
+        }
       if (LocaleCompare("remap",option+1) == 0)
         {
           Image
@@ -3315,7 +3302,9 @@ static void CLISimpleOperatorImage(MagickCLI *cli_wand,
                  option,arg1);
           if (IfMagickFalse(IsGeometry(arg2)))
             CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg2);
-          (void) ParseGeometry(arg2,&geometry_info);
+          flags=ParseGeometry(arg2,&geometry_info);
+          if ((flags & SigmaValue) == 0)
+            geometry_info.sigma=geometry_info.rho;
           new_image=StatisticImage(_image,(StatisticType)parse,
                (size_t) geometry_info.rho,(size_t) geometry_info.sigma,
                _exception);
@@ -3371,7 +3360,7 @@ static void CLISimpleOperatorImage(MagickCLI *cli_wand,
         }
       if (LocaleCompare("transform",option+1) == 0)
         {
-          /* DEPRECIATED -- should really use Distort AffineProjection */
+          CLIWandWarnDepreciated("+distort AffineProjection");
           new_image=AffineTransformImage(_image,&_draw_info->affine,_exception);
           break;
         }
@@ -3648,7 +3637,7 @@ WandExport void CLIListOperatorImages(MagickCLI *cli_wand,
         }
       if (LocaleCompare("average",option+1) == 0)
         {
-          /* DEPRECIATED - use -evaluate-sequence Mean */
+          CLIWandWarnDepreciated("-evaluate-sequence Mean");
           CLIListOperatorImages(cli_wand,"-evaluate-sequence","Mean",NULL);
           break;
         }
@@ -3772,7 +3761,7 @@ WandExport void CLIListOperatorImages(MagickCLI *cli_wand,
     {
       if (LocaleCompare("deconstruct",option+1) == 0)
         {
-          /* DEPRECIATED - use -layers CompareAny */
+          CLIWandWarnDepreciated("-layer CompareAny");
           CLIListOperatorImages(cli_wand,"-layer","CompareAny",NULL);
           break;
         }
@@ -4070,7 +4059,7 @@ WandExport void CLIListOperatorImages(MagickCLI *cli_wand,
     {
       if (LocaleCompare("map",option+1) == 0)
         {
-          /* DEPRECIATED use +remap */
+          CLIWandWarnDepreciated("+remap");
           (void) RemapImages(_quantize_info,_images,(Image *) NULL,_exception);
           break;
         }

diff --git a/MagickWand/wandcli-private.h b/MagickWand/wandcli-private.h
index 46bdeb73b83dd091fcbc7b81852fe78b4cd40b27..4b9618bb4b80e78417c157d9e62568763a959e31 100644 (file)
--- a/MagickWand/wandcli-private.h
+++ b/MagickWand/wandcli-private.h
@@ -30,6 +30,11 @@ extern "C" {
   (void) CLIThrowException(cli_wand,GetMagickModule(),severity,tag, \
        "'%s' '%s'",option, arg)
 
+#define CLIWandWarnDepreciated(message) \
+  if ( (cli_wand->process_flags & ProcessWarnDepreciated) != 0 ) \
+    (void) CLIThrowException(cli_wand,GetMagickModule(),OptionWarning, \
+       "DeprecatedOption", "'%s' use \"%s\" instead",option,message)
+
 #define CLIWandExceptionFile(severity,tag,context) \
 { char *message=GetExceptionMessage(errno); \
   (void) CLIThrowException(cli_wand,GetMagickModule(),severity,tag, \
@@ -50,6 +55,7 @@ extern "C" {
   { CLIWandExceptionArg(severity,tag,option,arg); return; }
 
 
+
 /* Define how options should be processed */
 typedef enum
 {
@@ -63,7 +69,7 @@ typedef enum
   ProcessExitOption           = 0x0100,  /* allow '-exit' use */
   ProcessScriptOption         = 0x0200,  /* allow '-script' use */
   ProcessReadOption           = 0x0400,  /* allow '-read' use */
-  ProcessReportDepreciated    = 0x0800,  /* report depreciated options */
+  ProcessWarnDepreciated      = 0x0800,  /* warn about depreciated options */
 
   /* Option Processing Flags */
   ProcessOneOptionOnly        = 0x4000,  /* Process one option only */

diff --git a/config/english.xml b/config/english.xml
index 25a6fb00dc11fa6e6402b26adc455fd2b5771b3e..7e075fba39342a2db5dfd94fcd08e1f6da825acc 100644 (file)
--- a/config/english.xml
+++ b/config/english.xml
@@ -595,8 +595,8 @@
         <message name="CurlyBrasesNestedTooDeeply">
           curly braces nested too deeply
         </message>
-        <message name="DeprecatedOption">
-          option is deprecated
+        <message name="DeprecatedOptionNoCode">
+          option deprecated, unable to execute
         </message>
         <message name="DivideByZero">
           divide by zero
@@ -921,6 +921,9 @@
         </message>
       </fatalerror>
       <warning>
+        <message name="DeprecatedOption">
+          option is deprecated
+        </message>
         <message name="GeometryDoesNotContainImage">
           geometry does not contain image
         </message>

diff --git a/config/francais.xml b/config/francais.xml
index ae00b5d13ebcd3f254205f098690d5e1fdc4387c..b2861214381f6202e774f5b9d59cad289de5d550 100644 (file)
--- a/config/francais.xml
+++ b/config/francais.xml
@@ -589,8 +589,8 @@
         <message name="CurlyBrasesNestedTooDeeply">
           trop d'imbrication de curly braces
         </message>
-        <message name="DepreciatedOption">
-          option est obsolète
+        <message name="DepreciatedOptionNoCode">
+          l'option dépréciée, incapable d'exécuter
         </message>
         <message name="DivideByZero">
           division par zéro
@@ -912,6 +912,9 @@
         </message>
       </fatalerror>
       <warning>
+        <message name="DepreciatedOption">
+          option est obsolète
+        </message>
         <message name="GeometryDoesNotContainImage">
           image non incluse dans la géométrie
         </message>