// from http://blogs.wankuma.com/ch3cooh/archive/2008/07/07/147667.aspx
        public static Image GetScaledImage(Image srcImg, int maxW, int maxH, ScaleMode mode)
        {
            int srcW = srcImg.Width;
            int srcH = srcImg.Height;
            Rectangle srcRect = new Rectangle(0, 0, srcW, srcH);

            int dstW, dstH;

            // FIXME 正方形の画像の場合は？
            // fitのときに横方向がはみ出す(縦に合わせられる)場合がある
            if ((srcW > srcH && mode == ScaleMode.Fit) || (srcH > srcW && mode == ScaleMode.Full))
            {
                dstW = maxW;
                dstH = (int)(((float)dstW / (float)srcW) * srcH);
            }
            else
            {
                dstH = maxH;
                dstW = (int)(((float)dstH / (float)srcH) * srcW);
            }

            Image dstImg = new Bitmap(dstW, dstH, PixelFormat.Format16bppRgb565);

            Rectangle dstRect = new Rectangle(0, 0, dstW, dstH);

            Graphics g = Graphics.FromImage(dstImg);
            g.DrawImage(srcImg, dstRect, srcRect, GraphicsUnit.Pixel);
            g.Dispose();

            return dstImg;
        }

 public void init(Vector2 butSize, Vector2 screenSize, ScaleMode scaleMode)
 {
     refButtonSize = butSize;
     refScreenSize = screenSize;
     smode = scaleMode;
     setButtonSize();
 }

 public void Initialize(Vector2 referenceButtonSize, Vector2 referenceScreenSize, int scaleMode)
 {
     this.referenceButtonSize = referenceButtonSize;
     this.referenceScreenSize = referenceScreenSize;
     this.scaleMode = (ScaleMode)scaleMode;
     SetNewButtonSize();
 }

        public static Vector2 ScaleFromTo(Vector2 from, Vector2 to, ScaleMode scaleMode = ScaleMode.StretchToFill)
        {
            Vector2 scale = Vector2.one;
            scale.x = to.x / from.x;
            scale.y = to.y / from.y;

            switch (scaleMode) {
            case ScaleMode.ScaleAndCrop:
                scale.x = scale.y = Mathf.Max(scale.x, scale.y);
                break;

            case ScaleMode.ScaleToFit:
                scale.x = scale.y = Mathf.Min(scale.x, scale.y);
                break;

            case ScaleMode.StretchToFill:
                //Do nothing
                break;

            default:
                Debug.LogException(new System.NotImplementedException("The Received ScaleMode." + scaleMode.ToString() + " is not implemented."));
                break;
            }

            return scale;
        }

 /// <summary>
 /// Creates a new instance of FeatureSymbolizer
 /// </summary>
 protected FeatureSymbolizer()
 {
     _scaleMode = ScaleMode.Simple;
     _smoothing = true;
     _isVisible = true;
     _unit = GraphicsUnit.Pixel;
 }

        private static Rectangle CalculateSourceRect(Size sourceImage, Size thumbImage, ScaleMode scaleMode)
        {
            int previewHeight = thumbImage.Height;
            int previewWidth = thumbImage.Width;

            switch (scaleMode)
            {
                case ScaleMode.Crop:
                    double wRatio = (double)sourceImage.Width / previewWidth;
                    double hRatio = (double)sourceImage.Height / previewHeight;
                    double coef = (double)previewHeight / previewWidth;
                    int resultWidth;
                    int resultHeight;
                    if (wRatio < hRatio)
                    {
                        resultWidth = sourceImage.Width;
                        resultHeight = (int)Math.Truncate(sourceImage.Width * coef);
                        return new Rectangle(0, (sourceImage.Height - resultHeight) / 2, resultWidth, resultHeight);
                    }
                    else
                    {
                        resultHeight = sourceImage.Height;
                        resultWidth = (int)Math.Truncate(sourceImage.Height / coef);
                        return new Rectangle((sourceImage.Width - resultWidth) / 2, 0, resultWidth, resultHeight);
                    }

                case ScaleMode.Insert:
                    return new Rectangle(0, 0, sourceImage.Width, sourceImage.Height);

                default:
                    return new Rectangle(0, 0, sourceImage.Width, sourceImage.Height);
            }
        }

        public GalleryModelBuilder(String baseHttpUrl, String siteName, String galleryHttpRootPath, String contentFilePath, String galleryRootFilePath, ScaleMode scaledImageScaleMode, double scaledImageWidth, double scaledImagedHeight, ScaleMode thumbScaleMode, double thumbImageWidth, double thumbImagedHeight)
        {
            _contentFilePath = contentFilePath;
            _baseHttpUrl = baseHttpUrl;
            _galleryContentRootFilePath = galleryRootFilePath;
            _galleryContentRootHttpPath = galleryHttpRootPath;

            _galleryHttpPathFormat = Settings.Default.Http_GalleryHttpPathFormat;
            _galleryHttpEnhancedPathFormat = Settings.Default.Http_GalleryHttpEnhancedPathFormat;
            _galleriesIndexHttpPathFormat = Settings.Default.Http_GalleriesIndexHttpPathFormat;
            _galleryCoverFileName = Settings.Default.File_GalleryCoverFileName;

            _imageFileTypeFilter = Settings.Default.Image_FileTypeFilter;

            _galleryFolderOriginalImages = Settings.Default.Folders_OringinalImages;
            _galleryFolderScaledImages = Settings.Default.Folders_ScaledImages;
            _galleryFolderThumbs = Settings.Default.Folders_Thumbs;

            _zipFileLQFormat = Settings.Default.Zip_FileNameFormat_LowQuality;
            _zipFileHQFormat = Settings.Default.Zip_FileNameFormat_HighQuality;

            _galleriesIndexHttpPath = String.Format(_galleriesIndexHttpPathFormat, _baseHttpUrl);

            _imageProcessor = new GalleryImageProcessor(scaledImageScaleMode, scaledImageWidth, scaledImagedHeight, thumbScaleMode, thumbImageWidth, thumbImagedHeight);
            _dataProcessor = new GalleryDataProcessor();
            _feedBuilder = new GalleryFeedBuilder(siteName, _galleriesIndexHttpPath);
            _coverRenderer = new GalleryCoverRenderer(_contentFilePath);
        }

        public static UrlBuilder Scale(this UrlBuilder target, ScaleMode mode)
        {
            if(target == null)
                throw new ArgumentNullException(nameof(target));

            target.QueryCollection.Add("scale", AddScaleString(mode));
            return target;
        }

 public void endDrag()
 {
     if (scaleMode == ScaleMode.none)
         return;
     scaleMode = ScaleMode.none;
     editableObject.draged = false;
     this.enabled = false;
     editableObject.rigidbody.detectCollisions = true;
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="position"></param>
 /// <param name="size"></param>
 /// <param name="tex"></param>
 /// <param name="texCoords"></param>
 /// <param name="scaleMode"></param>
 /// <param name="drawAlpha"></param>
 /// <param name="drawTransparent"></param>
 /// <param name="mat"></param>
 public Image( Vector2 position, Vector2 size, Texture tex = null, Rect? texCoords = null, ScaleMode scaleMode = ScaleMode.ScaleToFit, bool drawAlpha = false, bool drawTransparent = true, Material mat = null ) : base( position, size )
 {
     DrawTexture         = tex;
     Scale               = scaleMode;
     DrawAlpha           = drawAlpha;
     DrawTransparent     = drawTransparent;
     DrawMaterial        = mat;
     TexCoords           = texCoords;
 }

 public BasicButtonGUI(Rect r, Texture down, Texture up, Texture disableDown, Texture disableUp, bool bKeepSt = true)
 {
     TexDown = down;
     TexUp = up;
     TexDownDisable = disableDown;
     TexUpDisable = disableUp;
     rec = r;
     mKeepState = bKeepSt;
     scaleMode = ScaleMode.ScaleToFit;
     disableOnMouseMove = true;
 }

		public override void Reset()
		{
			texture = null;
			left = 0;
			top = 0;
			width = 1;
			height = 1;
			scaleMode = ScaleMode.StretchToFill;
			alphaBlend = true;
			imageAspect = 0;
			normalized = true;
		}

 //-----------------------------------------------------
 // Affiche une texture tilée. A appeler d'un OnGUI
 // (la texture sera devant toutes les GUITextures).
 public static void TileGUItexture(Texture texture, Rect tile, Rect areaToFill, ScaleMode scaleMode)
 {
     // Tiles an <areaToFill> with a <texture> which is scaled to the size
     // of a <tile> using a given <scaleMode>. Author: Isaac Manning Dart
     for (float y = areaToFill.y; y < areaToFill.y + areaToFill.height; y = y + tile.height)
     {
         for (float x = areaToFill.x; x < areaToFill.x + areaToFill.width; x = x + tile.width)
         {
             tile.x = x; tile.y = y;
             GUI.DrawTexture(tile, texture, scaleMode);
         }
     }
 }

 public override void Reset()
 {
     this.texture = null;
     this.screenRect = null;
     this.left = 0f;
     this.top = 0f;
     this.width = 1f;
     this.height = 1f;
     this.scaleMode = ScaleMode.StretchToFill;
     this.alphaBlend = true;
     this.imageAspect = 0f;
     this.normalized = true;
 }

 public GalleryImageProcessor(ScaleMode scaledImageScaleMode,
                              double scaledImageWidth,
                              double scaledImagedHeight,
                              ScaleMode thumbScaleMode,
                              double thumbImageWidth,
                              double thumbImagedHeight)
 {
     _scaledImageScaleMode = scaledImageScaleMode;
     _scaledImageWidth = scaledImageWidth;
     _scaledImagedHeight = scaledImagedHeight;
     _thumbScaleMode = thumbScaleMode;
     _thumbImageWidth = thumbImageWidth;
     _thumbImageHeight = thumbImagedHeight;
 }

        public FlexPaginator(C1FlexGrid flex, ScaleMode scaleMode, Size pageSize, Thickness margin, int maxPages)
        {
            // save parameters
            _margin = margin;
            _scaleMode = scaleMode;
            _pageSize = pageSize;

            // adjust page size for margins before building grid images
            pageSize.Width -= (margin.Left + margin.Right);
            pageSize.Height -= (margin.Top + margin.Bottom);

            // get grid images for each page
            _pages = flex.GetPageImages(scaleMode, pageSize, maxPages);
        }

        private static string AddScaleString(ScaleMode value)
        {
            if(value == ScaleMode.Both)
                return "both";

            if(value == ScaleMode.DownscaleOnly)
                return "down";

            if(value == ScaleMode.UpscaleCanvas)
                return "canvas";

            if(value == ScaleMode.UpscaleOnly)
                return "up";

            throw new NotImplementedException("Unrecognized ScaleMode value: " + value);
        }

        private static Rectangle CalculateSourceRect(string name, Size sourceImage, ScaleMode scaleMode)
        {
            int previewHeight = limitHeight.ContainsKey(name) ? limitHeight[name] : 0;
            int previewWidth = limitWidth.ContainsKey(name) ? limitWidth[name] : 0;

            int resultWidth;
            int resultHeight;

            if (scaleMode == ScaleMode.Cut)
            {

                double wRatio = (double)sourceImage.Width / (double)previewWidth;
                double hRatio = (double)sourceImage.Height / (double)previewHeight;

                double coef = (double)previewHeight / (double)previewWidth;

                if (wRatio < hRatio)
                {
                    resultWidth = sourceImage.Width;
                    resultHeight = (int)Math.Truncate(sourceImage.Width * coef);
                }
                else
                {
                    resultHeight = sourceImage.Height;
                    resultWidth = (int)Math.Truncate(sourceImage.Height / coef);
                }

                return new Rectangle(0, 0, resultWidth, resultHeight);
            }
            else
            {
                if (sourceImage.Width > sourceImage.Height)
                {
                    int shift = (int)Math.Truncate((sourceImage.Width - sourceImage.Height) / (double)2);
                    return new Rectangle(0, -shift, sourceImage.Width, sourceImage.Height + shift * 2);
                }
                else
                {
                    int shift = (int)Math.Truncate((sourceImage.Height - sourceImage.Width) / (double)2);
                    return new Rectangle(-shift, 0, sourceImage.Width + shift * 2, sourceImage.Height);
                }
            }
        }

        public ImageView(ImageView imageView)
        {
            LeftMargin = imageView.LeftMargin;
            TopMargin = imageView.TopMargin;
            RightMargin = imageView.RightMargin;
            BottomMargin = imageView.BottomMargin;

            Width = imageView.Width;
            Height = imageView.Height;
            Position = imageView.Position;
            Scale = imageView.Scale;
            Offset = imageView.Offset;

            ImageTexture = imageView.ImageTexture;
            ImageRect = imageView.ImageRect;
            ImageScaleMode = imageView.ImageScaleMode;
            IsDirty = imageView.IsDirty;

            Rect = imageView.Rect;
        }

        /// <summary>
        /// Sets the rectangle for this item
		/// <summary>
        /// <param name="x">The x coordinate.</param>
        /// <param name="y">The y coordinate.</param>
        /// <param name="w">The width.</param>
        /// <param name="h">The height.</param>
		public virtual void SetRectangle(float x, float y, float w, float h, bool isWorld, ScaleMode scale)
		{
			Scale = scale;
			WorldCoords = Vector2.zero;
			IsWorld = isWorld;		

			if (w <= 1 && h <= 1 )
			{
				w = Screen.width * w;
				h = Screen.height * h;
			}		

			if (isWorld)
			{											
				WorldCoords = new Vector2(x, y);
			} 
			else
			{		
				if (x <= 1 && y <= 1)
				{
					x = Screen.width * x;
					y = Screen.height * y;
				}				
			}
			
			if (Scale == ScaleMode.ScaleToFit)
			{
				if (Content.image != null)
				{	
					float r = 
						Math.Min(w / Content.image.width, 
						         h / Content.image.height);
					
					w = Content.image.width * r;
					h = Content.image.height * r;
				}
			}
			
			Rectangle = new Rect(x, y, w, h);
		}