添加项目文件。

zxing.core/xx/common/DecodingOptions.cs

@@ -0,0 +1,485 @@
+/*
+ * Copyright 2013 ZXing.Net authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+
+namespace ZXing.Common
+{
+   /// <summary>
+   /// Defines an container for encoder options
+   /// </summary>
+   public class DecodingOptions
+   {
+      /// <summary>
+      /// Gets the data container for all options
+      /// </summary>
+      public IDictionary<DecodeHintType, object> Hints { get; private set; }
+
+      public event Action<object, EventArgs> ValueChanged;
+
+      /// <summary>
+      /// Gets or sets a flag which cause a deeper look into the bitmap
+      /// </summary>
+      /// <value>
+      ///   <c>true</c> if [try harder]; otherwise, <c>false</c>.
+      /// </value>
+      public bool TryHarder
+      {
+         get
+         {
+            if (Hints.ContainsKey(DecodeHintType.TRY_HARDER))
+               return (bool)Hints[DecodeHintType.TRY_HARDER];
+            return false;
+         }
+         set
+         {
+            if (value)
+            {
+               Hints[DecodeHintType.TRY_HARDER] = true;
+            }
+            else
+            {
+               if (Hints.ContainsKey(DecodeHintType.TRY_HARDER))
+               {
+                  Hints.Remove(DecodeHintType.TRY_HARDER);
+               }
+            }
+         }
+      }
+
+      /// <summary>
+      /// Image is a pure monochrome image of a barcode.
+      /// </summary>
+      /// <value>
+      ///   <c>true</c> if monochrome image of a barcode; otherwise, <c>false</c>.
+      /// </value>
+      public bool PureBarcode
+      {
+         get
+         {
+            if (Hints.ContainsKey(DecodeHintType.PURE_BARCODE))
+               return (bool)Hints[DecodeHintType.PURE_BARCODE];
+            return false;
+         }
+         set
+         {
+            if (value)
+            {
+               Hints[DecodeHintType.PURE_BARCODE] = true;
+            }
+            else
+            {
+               if (Hints.ContainsKey(DecodeHintType.PURE_BARCODE))
+               {
+                  Hints.Remove(DecodeHintType.PURE_BARCODE);
+               }
+            }
+         }
+      }
+
+      /// <summary>
+      /// Specifies what character encoding to use when decoding, where applicable (type String)
+      /// </summary>
+      /// <value>
+      /// The character set.
+      /// </value>
+      public string CharacterSet
+      {
+         get
+         {
+            if (Hints.ContainsKey(DecodeHintType.CHARACTER_SET))
+               return (string)Hints[DecodeHintType.CHARACTER_SET];
+            return null;
+         }
+         set
+         {
+            if (value != null)
+            {
+               Hints[DecodeHintType.CHARACTER_SET] = value;
+            }
+            else
+            {
+               if (Hints.ContainsKey(DecodeHintType.CHARACTER_SET))
+               {
+                  Hints.Remove(DecodeHintType.CHARACTER_SET);
+               }
+            }
+         }
+      }
+
+      /// <summary>
+      /// Image is known to be of one of a few possible formats.
+      /// Maps to a {@link java.util.List} of {@link BarcodeFormat}s.
+      /// </summary>
+      /// <value>
+      /// The possible formats.
+      /// </value>
+      public IList<BarcodeFormat> PossibleFormats
+      {
+         get
+         {
+            if (Hints.ContainsKey(DecodeHintType.POSSIBLE_FORMATS))
+               return (IList<BarcodeFormat>)Hints[DecodeHintType.POSSIBLE_FORMATS];
+            return null;
+         }
+         set
+         {
+            if (value != null)
+            {
+               Hints[DecodeHintType.POSSIBLE_FORMATS] = value;
+            }
+            else
+            {
+               if (Hints.ContainsKey(DecodeHintType.POSSIBLE_FORMATS))
+               {
+                  Hints.Remove(DecodeHintType.POSSIBLE_FORMATS);
+               }
+            }
+         }
+      }
+
+      /// <summary>
+      /// if Code39 could be detected try to use extended mode for full ASCII character set
+      /// </summary>
+      public bool UseCode39ExtendedMode
+      {
+         get
+         {
+            if (Hints.ContainsKey(DecodeHintType.USE_CODE_39_EXTENDED_MODE))
+               return (bool)Hints[DecodeHintType.USE_CODE_39_EXTENDED_MODE];
+            return false;
+         }
+         set
+         {
+            if (value)
+            {
+               Hints[DecodeHintType.USE_CODE_39_EXTENDED_MODE] = true;
+            }
+            else
+            {
+               if (Hints.ContainsKey(DecodeHintType.USE_CODE_39_EXTENDED_MODE))
+               {
+                  Hints.Remove(DecodeHintType.USE_CODE_39_EXTENDED_MODE);
+               }
+            }
+         }
+      }
+
+      /// <summary>
+      /// Don't fail if a Code39 is detected but can't be decoded in extended mode.
+      /// Return the raw Code39 result instead. Maps to <see cref="bool" />.
+      /// </summary>
+      public bool UseCode39RelaxedExtendedMode
+      {
+         get
+         {
+            if (Hints.ContainsKey(DecodeHintType.RELAXED_CODE_39_EXTENDED_MODE))
+               return (bool)Hints[DecodeHintType.RELAXED_CODE_39_EXTENDED_MODE];
+            return false;
+         }
+         set
+         {
+            if (value)
+            {
+               Hints[DecodeHintType.RELAXED_CODE_39_EXTENDED_MODE] = true;
+            }
+            else
+            {
+               if (Hints.ContainsKey(DecodeHintType.RELAXED_CODE_39_EXTENDED_MODE))
+               {
+                  Hints.Remove(DecodeHintType.RELAXED_CODE_39_EXTENDED_MODE);
+               }
+            }
+         }
+      }
+
+      /// <summary>
+      /// If true, return the start and end digits in a Codabar barcode instead of stripping them. They
+      /// are alpha, whereas the rest are numeric. By default, they are stripped, but this causes them
+      /// to not be. Doesn't matter what it maps to; use <see cref="bool" />.
+      /// </summary>
+      public bool ReturnCodabarStartEnd
+      {
+         get
+         {
+            if (Hints.ContainsKey(DecodeHintType.RETURN_CODABAR_START_END))
+               return (bool)Hints[DecodeHintType.RETURN_CODABAR_START_END];
+            return false;
+         }
+         set
+         {
+            if (value)
+            {
+               Hints[DecodeHintType.RETURN_CODABAR_START_END] = true;
+            }
+            else
+            {
+               if (Hints.ContainsKey(DecodeHintType.RETURN_CODABAR_START_END))
+               {
+                  Hints.Remove(DecodeHintType.RETURN_CODABAR_START_END);
+               }
+            }
+         }
+      }
+
+      /// <summary>
+      /// Assume the barcode is being processed as a GS1 barcode, and modify behavior as needed.
+      /// For example this affects FNC1 handling for Code 128 (aka GS1-128).
+      /// </summary>
+      /// <value>
+      ///   <c>true</c> if it should assume GS1; otherwise, <c>false</c>.
+      /// </value>
+      public bool AssumeGS1
+      {
+         get
+         {
+            if (Hints.ContainsKey(DecodeHintType.ASSUME_GS1))
+               return (bool)Hints[DecodeHintType.ASSUME_GS1];
+            return false;
+         }
+         set
+         {
+            if (value)
+            {
+               Hints[DecodeHintType.ASSUME_GS1] = true;
+            }
+            else
+            {
+               if (Hints.ContainsKey(DecodeHintType.ASSUME_GS1))
+               {
+                  Hints.Remove(DecodeHintType.ASSUME_GS1);
+               }
+            }
+         }
+      }
+
+      /// <summary>
+      /// Assume MSI codes employ a check digit. Maps to <see cref="bool" />.
+      /// </summary>
+      /// <value>
+      ///   <c>true</c> if it should assume a MSI check digit; otherwise, <c>false</c>.
+      /// </value>
+      public bool AssumeMSICheckDigit
+      {
+         get
+         {
+            if (Hints.ContainsKey(DecodeHintType.ASSUME_MSI_CHECK_DIGIT))
+               return (bool)Hints[DecodeHintType.ASSUME_MSI_CHECK_DIGIT];
+            return false;
+         }
+         set
+         {
+            if (value)
+            {
+               Hints[DecodeHintType.ASSUME_MSI_CHECK_DIGIT] = true;
+            }
+            else
+            {
+               if (Hints.ContainsKey(DecodeHintType.ASSUME_MSI_CHECK_DIGIT))
+               {
+                  Hints.Remove(DecodeHintType.ASSUME_MSI_CHECK_DIGIT);
+               }
+            }
+         }
+      }
+
+      /// <summary>
+      /// Allowed lengths of encoded data -- reject anything else. Maps to an int[].
+      /// </summary>
+      public int[] AllowedLengths
+      {
+         get
+         {
+            if (Hints.ContainsKey(DecodeHintType.ALLOWED_LENGTHS))
+               return (int[])Hints[DecodeHintType.ALLOWED_LENGTHS];
+            return null;
+         }
+         set
+         {
+            if (value != null && value.Length > 0)
+            {
+               Hints[DecodeHintType.ALLOWED_LENGTHS] = value;
+            }
+            else
+            {
+               if (Hints.ContainsKey(DecodeHintType.ALLOWED_LENGTHS))
+               {
+                  Hints.Remove(DecodeHintType.ALLOWED_LENGTHS);
+               }
+            }
+         }
+      }
+
+      /// <summary>
+      /// Allowed extension lengths for EAN or UPC barcodes. Other formats will ignore this.
+      /// Maps to an <see cref="Array.int" /> of the allowed extension lengths, for example [2], [5], or [2, 5].
+      /// If it is optional to have an extension, do not set this hint. If this is set,
+      /// and a UPC or EAN barcode is found but an extension is not, then no result will be returned
+      /// at all.
+      /// </summary>
+      public int[] AllowedEANExtensions
+      {
+         get
+         {
+            if (Hints.ContainsKey(DecodeHintType.ALLOWED_EAN_EXTENSIONS))
+               return (int[])Hints[DecodeHintType.ALLOWED_EAN_EXTENSIONS];
+            return null;
+         }
+         set
+         {
+            if (value != null && value.Length > 0)
+            {
+               Hints[DecodeHintType.ALLOWED_EAN_EXTENSIONS] = value;
+            }
+            else
+            {
+               if (Hints.ContainsKey(DecodeHintType.ALLOWED_EAN_EXTENSIONS))
+               {
+                  Hints.Remove(DecodeHintType.ALLOWED_EAN_EXTENSIONS);
+               }
+            }
+         }
+      }
+
+      /// <summary>
+      /// Initializes a new instance of the <see cref="DecodingOptions"/> class.
+      /// </summary>
+      public DecodingOptions()
+      {
+         var hints = new ChangeNotifyDictionary<DecodeHintType, object>();
+         Hints = hints;
+         UseCode39ExtendedMode = true;
+         UseCode39RelaxedExtendedMode = true;
+         hints.ValueChanged += (o, args) => { if (ValueChanged != null) ValueChanged(this, EventArgs.Empty); };
+      }
+
+      private class ChangeNotifyDictionary<TKey, TValue>: IDictionary<TKey, TValue>
+      {
+         private readonly IDictionary<TKey, TValue> values;
+
+         public event Action<object, EventArgs> ValueChanged;
+
+         public ChangeNotifyDictionary()
+         {
+            values = new Dictionary<TKey, TValue>();
+         }
+
+         private void OnValueChanged()
+         {
+            if (ValueChanged != null)
+               ValueChanged(this, EventArgs.Empty);
+         }
+
+         public void Add(TKey key, TValue value)
+         {
+            values.Add(key, value);
+            OnValueChanged();
+         }
+
+         public bool ContainsKey(TKey key)
+         {
+            return values.ContainsKey(key);
+         }
+
+         public ICollection<TKey> Keys
+         {
+            get { return values.Keys; }
+         }
+
+         public bool Remove(TKey key)
+         {
+            var result = values.Remove(key);
+            OnValueChanged();
+            return result;
+         }
+
+         public bool TryGetValue(TKey key, out TValue value)
+         {
+            return values.TryGetValue(key, out value);
+         }
+
+         public ICollection<TValue> Values
+         {
+            get { return values.Values; }
+         }
+
+         public TValue this[TKey key]
+         {
+            get
+            {
+               return values[key];
+            }
+            set
+            {
+               values[key] = value;
+               OnValueChanged();
+            }
+         }
+
+         public void Add(KeyValuePair<TKey, TValue> item)
+         {
+            values.Add(item);
+            OnValueChanged();
+         }
+
+         public void Clear()
+         {
+            values.Clear();
+            OnValueChanged();
+         }
+
+         public bool Contains(KeyValuePair<TKey, TValue> item)
+         {
+            return values.Contains(item);
+         }
+
+         public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
+         {
+            values.CopyTo(array, arrayIndex);
+         }
+
+         public int Count
+         {
+            get { return values.Count; }
+         }
+
+         public bool IsReadOnly
+         {
+            get { return values.IsReadOnly; }
+         }
+
+         public bool Remove(KeyValuePair<TKey, TValue> item)
+         {
+            var result = values.Remove(item);
+            OnValueChanged();
+
+            return result;
+         }
+
+         public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
+         {
+            return values.GetEnumerator();
+         }
+
+         System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+         {
+            return ((System.Collections.IEnumerable)values).GetEnumerator();
+         }
+      }
+   }
+}