MARKUS

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Globalization;

using System.Data.Entity.Design;

using System.IO;

namespace ImageFields

{

    public abstract class ImageFieldsBase : DZTEvents

    {

        // Fields

        private bool conversionCopyMetadata = false;

        private double conversionImageQuality = 0.8;

        private ImageFormat conversionTileFormat = ImageFormat.AutoSelect;

        private int conversionTileOverlap = 1;

        private int conversionTileSize = 0xfe;

        protected const bool DefaultConversionCopyMetadata = false;

        protected const double DefaultConversionImageQuality = 0.8;

        protected const ImageFormat DefaultConversionTileFormat = ImageFormat.AutoSelect;

        protected const int DefaultConversionTileOverlap = 1;

        protected const int DefaultConversionTileSize = 0xfe;

        protected const ImageFormat DefaultImageFormat = ImageFormat.AutoSelect;

        public const double DefaultImageQuality = 0.8;

        protected const int DefaultMaxLevel = 30;

        protected const int DefaultTileOverlap = 1;

        protected const int DefaultTileSize = 0xfe;

        private double imageQuality = 0.8;

        private int maxLevel = 30;

        private bool lowLevelPass = false;

        public const int MaxTileSize = 0x800;

        public const int MinTileSize = 1;

        internal EntityStoreSchemaFilterEffect notInUse;

        private ImageFormat tileFormat = ImageFormat.AutoSelect;

        private int tileOverlap = 1;

        private int tileSize = 0xfe;

        // Methods

        protected ImageFieldsBase()

        {

            this.conversionImageQuality = 0.8;

            this.conversionTileSize = 0xfe;

            this.conversionTileOverlap = 1;

            this.conversionTileFormat = ImageFormat.AutoSelect;

            this.conversionCopyMetadata = false;

            this.notInUse = EntityStoreSchemaFilterEffect.Allow;

            this.UseOptimizations = false;

            this.ServerFormat = ServerFormats.Default;

        }

        internal string CreateDirectories(string outputPath, int maxLevel)

        {

            string str = Path.ChangeExtension(outputPath, null) + "_files";

            DirectoryEventArgs e = new DirectoryEventArgs

            {

                DirectoryName = str

            };

            base.OnCreateDirectory(e);

            int _minLevel = 0;

            if (lowLevelPass)

                _minLevel = 8;

            for (int i = _minLevel; i <= maxLevel; i++)

            {

                string str2 = Path.Combine(str, i.ToString(CultureInfo.InvariantCulture));

                e.DirectoryName = str2;

                base.OnCreateDirectory(e);

            }

            return str;

        }

        internal static ICollection<Image> StringsToImages(ICollection<string> strings)

        {

            List<Image> list = new List<Image>();

            foreach (string str in strings)

            {

                Image item = new Image(str)

                {

                    ViewportWidth = 0.0

                };

                list.Add(item);

            }

            return list;

        }

        // Properties

        public bool ConversionCopyMetadata

        {

            get

            {

                return this.conversionCopyMetadata;

            }

            set

            {

                this.conversionCopyMetadata = value;

            }

        }

        public double ConversionImageQuality

        {

            get

            {

                return this.conversionImageQuality;

            }

            set

            {

                if ((value > 1.0) || (value < 0.0))

                {

                    throw new ArgumentOutOfRangeException("value", "ConversionImageQuality must be between 0 and 1.");

                }

                this.conversionImageQuality = value;

            }

        }

        public ImageFormat ConversionTileFormat

        {

            get

            {

                return this.conversionTileFormat;

            }

            set

            {

                this.conversionTileFormat = value;

            }

        }

        public int ConversionTileOverlap

        {

            get

            {

                return this.conversionTileOverlap;

            }

            set

            {

                if ((value > (this.conversionTileSize / 2)) || (value < 0))

                {

                    throw new ArgumentOutOfRangeException("value", "ConversionTileOverlap must be between 0 and half the ConversionTileSize.");

                }

                this.conversionTileOverlap = value;

            }

        }

        public virtual int ConversionTileSize

        {

            get

            {

                return this.conversionTileSize;

            }

            set

            {

                if ((value > 0x800) || (value < 1))

                {

                    string[] strArray = new string[5];

                    strArray[0] = "ConversionTileSize must be between ";

                    int num = 1;

                    strArray[1] = num.ToString(CultureInfo.CurrentUICulture);

                    strArray[2] = " and ";

                    strArray[3] = 0x800.ToString(CultureInfo.CurrentUICulture);

                    strArray[4] = ".";

                    throw new ArgumentOutOfRangeException("value", string.Concat(strArray));

                }

                this.conversionTileSize = value;

            }

        }

        public double ImageQuality

        {

            get

            {

                return this.imageQuality;

            }

            set

            {

                if ((value > 1.0) || (value < 0.0))

                {

                    throw new ArgumentOutOfRangeException("value", "Image Quality must be between 0 and 1.");

                }

                this.imageQuality = value;

            }

        }

        public bool LowLevelPass

        {

            get

            {

                return this.lowLevelPass;

            }

            set

            {

                this.lowLevelPass = value;

            }

        }

        public int MaxLevel

        {

            get

            {

                return this.maxLevel;

            }

            set

            {

                if ((value > 30) || (value < 0))

                {

                    throw new ArgumentOutOfRangeException("value", "Max Level must be between 0 and " + 30 + ".");

                }

                this.maxLevel = value;

            }

        }

        public ServerFormats ServerFormat { get; set; }

        public ImageFormat TileFormat

        {

            get

            {

                return this.tileFormat;

            }

            set

            {

                this.tileFormat = value;

            }

        }

        public int TileOverlap

        {

            get

            {

                return this.tileOverlap;

            }

            set

            {

                if ((value > (this.tileSize / 2)) || (value < 0))

                {

                    throw new ArgumentOutOfRangeException("value", "TileOverlap must be between 0 and half the TileSize.");

                }

                this.tileOverlap = value;

            }

        }

        public virtual int TileSize

        {

            get

            {

                return this.tileSize;

            }

            set

            {

                if ((value > 0x800) || (value < 1))

                {

                    string[] strArray = new string[5];

                    strArray[0] = "TileSize must be between ";

                    int num = 1;

                    strArray[1] = num.ToString(CultureInfo.CurrentUICulture);

                    strArray[2] = " and ";

                    strArray[3] = 0x800.ToString(CultureInfo.CurrentUICulture);

                    strArray[4] = ".";

                    throw new ArgumentOutOfRangeException("value", string.Concat(strArray));

                }

                this.tileSize = value;

            }

        }

        public bool UseOptimizations { get; set; }

    }

}