public DrawWait(int s, int width, int height)
            {
                this.style = s;
                this.width = width;
                this.height = height;
                this.color = new LColor(1f, 1f, 1f);
                switch (style)
                {
                    case 0:
                        int r1 = width / 8,
                        r2 = height / 8;
                        this.r = ((r1 < r2) ? r1 : r2) / 2;
                        this.list = new List<object>(Arrays.AsList<object>(new object[] {
											new RectBox(sx + 3 * r, sy + 0 * r, 2 * r, 2 * r),
											new RectBox(sx + 5 * r, sy + 1 * r, 2 * r, 2 * r),
											new RectBox(sx + 6 * r, sy + 3 * r, 2 * r, 2 * r),
											new RectBox(sx + 5 * r, sy + 5 * r, 2 * r, 2 * r),
											new RectBox(sx + 3 * r, sy + 6 * r, 2 * r, 2 * r),
											new RectBox(sx + 1 * r, sy + 5 * r, 2 * r, 2 * r),
											new RectBox(sx + 0 * r, sy + 3 * r, 2 * r, 2 * r),
											new RectBox(sx + 1 * r, sy + 1 * r, 2 * r, 2 * r) }));
                        break;
                    case 1:
                        this.Fill = new LColor(165, 0, 0, 255);
                        this.paintX = (width - ARCRADIUS);
                        this.paintY = (height - ARCRADIUS);
                        this.paintWidth = paintX + ARCRADIUS;
                        this.paintHeight = paintY + ARCRADIUS;
                        break;
                }
            }

        public EmulatorButton(LTexture img, int w, int h, int x, int y,
                bool flag, int sizew, int sizeh)
        {
            this.color = new LColor(LColor.gray.R, LColor.gray.G,
                            LColor.gray.B, 125);
            img.LoadTexture();
            if (flag)
               {
                this.bitmap = img.GetSubTexture(x, y, w, h);
            }
            else
            {
                this.bitmap = img;
            }
            if (bitmap.GetWidth() != sizew || bitmap.GetHeight() != sizeh)
            {

                LTexture tmp = bitmap;
                this.bitmap = bitmap.Scale(sizew, sizeh);

                if (tmp != null)
                {
                    tmp.Dispose();
                    tmp = null;
                }
            }
            this.bounds = new RectBox(0, 0, bitmap.GetWidth(), bitmap.GetHeight());
        }

		public Label(LFont font, string label, int x, int y) {
			this.font = font;
			this.label = label;
			this.color = LColor.black;
			this.visible = true;
			this.SetLocation(x, y);
		}

 public static LTexture FilterColor(string res, LColor height, Loon.Core.Graphics.Opengl.LTexture.Format format)
 {
     uint color = height.GetRGB();
     LImage tmp = LImage.CreateImage(res);
     LImage image = LImage.CreateImage(tmp.GetWidth(), tmp.GetHeight(), true);
     LGraphics g = image.GetLGraphics();
     g.DrawImage(tmp, 0, 0);
     g.Dispose();
     if (tmp != null)
     {
         tmp.Dispose();
         tmp = null;
     }
     Color[] pixels = image.GetPixels();
     int size = pixels.Length;
     for (int i = 0; i < size; i++)
     {
         if (pixels[i].PackedValue == color)
         {
             pixels[i].PackedValue = LSystem.TRANSPARENT;
         }
     }
     image.SetFormat(format);
     image.SetPixels(pixels, image.GetWidth(), image.GetHeight());
     LTexture texture = image.GetTexture();
     if (image != null)
     {
         image.Dispose();
         image = null;
     }
     return texture;
 }

		private LGradation(LColor s, LColor e, int w, int h, int alpha) {
			this.start = s;
			this.end = e;
			this.width = w;
			this.height = h;
			this.alpha = alpha;
		}

		public LColor GetColor(uint c) {
            LColor color = (LColor)CollectionUtils.Get(ColorMap, c);
			if (color == null) {
				color = new LColor(c);
                CollectionUtils.Put(ColorMap, c, color);
			}
			return color;
		}

		public FadeEffect(LColor c, int delay, int type, int w, int h) {
			this.visible = true;
			this.type = type;
			this.SetDelay(delay);
			this.SetColor(c);
			this.width = w;
			this.height = h;
		}

		public void Draw(int idx, SpriteBatch batch, float x, float y,
				float rotation, float sx, float sy, LColor color) {
			RectBox rect = this._rectList[idx];
			batch.SetColor(color);
			batch.Draw(_texture, x, y, anchor.x, anchor.y, rect.width, rect.height,
					sx, sy, MathUtils.ToDegrees(rotation), rect.x, rect.y,
					rect.width, rect.height, false, false);
			batch.ResetColor();
		}

 public ArcEffect(LColor c, int x, int y, int width, int height)
 {
     this.SetLocation(x, y);
     this.width = width;
     this.height = height;
     this.timer = new LTimer(200);
     this.color = (c == null) ? LColor.black : c;
     this.visible = true;
 }

        public static LTransition NewArc(LColor c)
        {
            if (GLEx.Self != null)
            {

                LTransition transition = new LTransition();
                transition.SetTransitionListener(new _Arc(c));
                transition.SetDisplayGameUI(true);
                transition.code = 1;
                return transition;
            }
            return null;
        }

 public void Draw(GLEx g, int x, int y, int sx, int sy, LColor color)
 {
     if (target.IsBatch())
     {
         float nx = sx * tw;
         float ny = sy * th;
         target.Draw(x, y, tw, th, nx, ny, nx + tw, ny + th, color);
     }
     else
     {
         CheckImage(sx, sy);
         g.DrawTexture(subImages[sx][sy], x, y);
     }
 }

 public static LTexture CreateTexture(int width, int height, LColor c)
 {
     LImage image = LImage.CreateImage(width, height, false);
     LGraphics g = image.GetLGraphics();
     g.SetColor(c);
     g.FillRect(0, 0, width, height);
     g.Dispose();
     LTexture tex2d = image.GetTexture();
     if (image != null)
     {
         image.Dispose();
         image = null;
     }
     return tex2d;
 }

 public LColor GetColor(float r, float g, float b, float a)
 {
     int hashCode = 1;
     hashCode = LSystem.Unite(hashCode, r);
     hashCode = LSystem.Unite(hashCode, g);
     hashCode = LSystem.Unite(hashCode, b);
     hashCode = LSystem.Unite(hashCode, a);
     LColor color = (LColor)CollectionUtils.Get(colorMap, hashCode);
     if (color == null)
     {
         color = new LColor(r, g, b, a);
         CollectionUtils.Put(colorMap, hashCode
             , color);
     }
     return color;
 }

 public Blood(LColor c, int x, int y)
 {
     this.SetLocation(x, y);
     this.color = c;
     this.timer = new LTimer(20);
     this.drops = new Drop[20];
     this.limit = 50;
     for (int i = 0; i < drops.Length; ++i)
     {
         SetBoolds(i, x, y, 6.0f * (MathUtils.Random() - 0.5f), -2.0f
                 * MathUtils.Random());
     }
     this.xSpeed = 0F;
     this.ySpeed = 0.5F;
     this.step = 0;
     this.visible = true;
 }

		public static LGradation GetInstance(LColor s, LColor e, int w, int h,
				int alpha) {
			if (gradations == null) {
                gradations = new Dictionary<string, LGradation>(10);
			}
			int hashCode = 1;
			hashCode = LSystem.Unite(hashCode, s.GetRGB());
			hashCode = LSystem.Unite(hashCode, e.GetRGB());
			hashCode = LSystem.Unite(hashCode, w);
			hashCode = LSystem.Unite(hashCode, h);
			hashCode = LSystem.Unite(hashCode, alpha);
			string key = Convert.ToString(hashCode);
			LGradation o = (LGradation) CollectionUtils.Get(gradations,key);
			if (o == null) {
                CollectionUtils.Put(gradations,key, o = new LGradation(s, e, w, h, alpha));
			}
			return o;
		}

 public LTexture LoadBarColor(LColor c1, LColor c2, LColor c3)
 {
     if (colors.Count > 10)
     {
         lock (colors)
         {
             foreach (LTexture tex2d in colors.Values)
             {
                 if (tex2d != null)
                 {
                     tex2d.Destroy();
                 }
             }
             colors.Clear();
         }
     }
     int hash = 1;
     hash = LSystem.Unite(hash, c1.GetRGB());
     hash = LSystem.Unite(hash, c2.GetRGB());
     hash = LSystem.Unite(hash, c3.GetRGB());
     LTexture texture = null;
     lock (colors)
     {
         texture = (LTexture)CollectionUtils.Get(colors, hash);
     }
     if (texture == null)
     {
         LImage image = LImage.CreateImage(8, 8, false);
         LGraphics g = image.GetLGraphics();
         g.SetColor(c1);
         g.FillRect(0, 0, 4, 4);
         g.SetColor(c2);
         g.FillRect(4, 0, 4, 4);
         g.SetColor(c3);
         g.FillRect(0, 4, 4, 4);
         g.Dispose();
         texture = image.GetTexture();
         CollectionUtils.Put(colors, hash, texture);
     }
     return (this.texture = texture);
 }

 public static LTexture FilterLimitColor(string res, LColor start,
         LColor end, Loon.Core.Graphics.Opengl.LTexture.Format format)
 {
     int sred = start.R;
     int sgreen = start.G;
     int sblue = start.B;
     int ered = end.R;
     int egreen = end.G;
     int eblue = end.B;
     LImage tmp = LImage.CreateImage(res);
     LImage image = LImage.CreateImage(tmp.GetWidth(), tmp.GetHeight(), true);
     LGraphics g = image.GetLGraphics();
     g.DrawImage(tmp, 0, 0);
     g.Dispose();
     if (tmp != null)
     {
         tmp.Dispose();
         tmp = null;
     }
     Color[] pixels = image.GetPixels();
     int size = pixels.Length;
     for (int i = 0; i < size; i++)
     {
         Color pixel = pixels[i];
         if ((pixel.R >= sred && pixel.G >= sgreen && pixel.B >= sblue)
                 && (pixel.R <= ered && pixel.G <= egreen && pixel.B <= eblue))
         {
             pixels[i].PackedValue = LSystem.TRANSPARENT;
         }
     }
     image.SetFormat(format);
     image.SetPixels(pixels, image.GetWidth(), image.GetHeight());
     LTexture texture = image.GetTexture();
     if (image != null)
     {
         image.Dispose();
         image = null;
     }
     return texture;
 }

        public Cycle(List<object[]> path_0, int x_1, int y_2, int w, int h)
        {
            if (path_0 != null)
            {
                CollectionUtils.Add(data, CollectionUtils.ToArray(path_0));
                isUpdate = true;
            }
            else
            {
                data = new List<object[]>(10);
            }

            this.SetLocation(x_1, y_2);
            this.timer = new LTimer(25);
            this.color = LColor.white;
            this.points = new List<CycleProgress>();
            this.multiplier = 1;
            this.pointDistance = 0.05f;
            this.padding = 0;
            this.stepType = 0;
            this.stepsPerFrame = 1;
            this.trailLength = 1;
            this.scaleX = 1;
            this.scaleY = 1;
            this.alpha = 1;
            this.blockWidth = w;
            this.blockHeight = h;
            this.blockHalfWidth = w / 2;
            this.blockHalfHeight = h / 2;
            if (signatures == null)
            {
                signatures = new Dictionary<Int32, float[]>(3);
                CollectionUtils.Put(signatures, ARC, new float[] { 1, 1, 3, 2, 2, 0 });
                CollectionUtils.Put(signatures, BEZIER, new float[] { 1, 1, 1, 1, 1, 1, 1, 1 });
                CollectionUtils.Put(signatures, LINE, new float[] { 1, 1, 1, 1 });
            }
            this.Setup();
            this.isVisible = true;
        }

 public Light(float x, float y, float str, LColor col)
 {
     this.xpos = x;
     this.ypos = y;
     this.strength = str;
     this.color = col;
 }

 public void SetFilterColor(LColor f)
 {
     this.filterColor.SetColor(f);
 }