public override void PaintValue(PaintValueEventArgs e)
		{
			try
			{
				if(e==null || e.Value==null)
					return;
				int iIndex=(int)e.Value;
				System.Drawing.Image img=this.GetImage(e.Context,iIndex);
				if(img==null)
					return;
				PaintValueEventArgs pi=new PaintValueEventArgs(e.Context,img,e.Graphics,e.Bounds);
                if (img != null)
                {
                    Rectangle r = e.Bounds;
                    r.Width--;
                    r.Height--;
                    e.Graphics.DrawRectangle(SystemPens.WindowFrame, r);
                    e.Graphics.DrawImage(img, e.Bounds);
                }

				//m_ImageEditor.PaintValue(pi);
				//m_ImageEditor.PaintValue(img,e.Graphics,e.Bounds);
			}
			catch{}
		}

        public override void PaintValue(PaintValueEventArgs e)
        {
            if (e.Value is Color && ((Color)e.Value).A <= byte.MaxValue)
            {
                Color xnacolor = (Color)e.Value;
                System.Drawing.Color syscolor = System.Drawing.Color.FromArgb(xnacolor.A, xnacolor.R, xnacolor.G, xnacolor.B);

                int oneThird = e.Bounds.Width / 3;
                using (System.Drawing.SolidBrush brush = new System.Drawing.SolidBrush(System.Drawing.Color.DarkGray))
                {
                    e.Graphics.FillRectangle(brush, new System.Drawing.Rectangle(e.Bounds.X + 1, e.Bounds.Y + 1, 4, 4));
                    e.Graphics.FillRectangle(brush, new System.Drawing.Rectangle(e.Bounds.X + 9, e.Bounds.Y + 1, 4, 4));
                    e.Graphics.FillRectangle(brush, new System.Drawing.Rectangle(e.Bounds.X + 17, e.Bounds.Y + 1, 2, 4));

                    e.Graphics.FillRectangle(brush, new System.Drawing.Rectangle(e.Bounds.X + 5, e.Bounds.Y + 5, 4, 4));
                    e.Graphics.FillRectangle(brush, new System.Drawing.Rectangle(e.Bounds.X + 13, e.Bounds.Y + 5, 4, 4));

                    e.Graphics.FillRectangle(brush, new System.Drawing.Rectangle(e.Bounds.X + 1, e.Bounds.Y + 9, 4, 3));
                    e.Graphics.FillRectangle(brush, new System.Drawing.Rectangle(e.Bounds.X + 9, e.Bounds.Y + 9, 4, 3));
                    e.Graphics.FillRectangle(brush, new System.Drawing.Rectangle(e.Bounds.X + 17, e.Bounds.Y + 9, 2, 3));

                }
                using (System.Drawing.SolidBrush brush = new System.Drawing.SolidBrush(syscolor))
                {
                    e.Graphics.FillRectangle(brush, new System.Drawing.Rectangle(e.Bounds.X, e.Bounds.Y, e.Bounds.Width, e.Bounds.Height - 1));
                }
            }

            if (e.Value is System.Drawing.Color)
            {
                base.PaintValue(e);
            }
        }

        /// <summary>
        /// Paints a representation of the value of an object using the specified <see cref="T:System.Drawing.Design.PaintValueEventArgs"/>.
        /// </summary>
        /// <param name="e">A <see cref="T:System.Drawing.Design.PaintValueEventArgs"/> that indicates what to paint and where to paint it.</param>
        public override void PaintValue(PaintValueEventArgs e)
        {
            Brush backgroundBrush = new SolidBrush(Color.FromArgb((int)((float)e.Value * 255f), Color.White));

            e.Graphics.FillRectangle(Brushes.Black, e.Bounds);
            e.Graphics.FillRectangle(backgroundBrush, e.Bounds);
        }

        public override void PaintValue(PaintValueEventArgs e)
        {
            var inheritableColor = (InheritableColor)e.Value;

            using (var brush = new SolidBrush(inheritableColor.Value))
                e.Graphics.FillRectangle(brush, e.Bounds);
        }

      public override void PaintValue(PaintValueEventArgs pe)
      {
         Image image = null;
         int imageIndex = 0;

         if (!int.TryParse(pe.Value.ToString(), out imageIndex))
            return;

         ImageList imageList = null;

         PropertyDescriptorCollection PropertyCollection
                           = TypeDescriptor.GetProperties(instance);

         PropertyDescriptor property;
         if ((property = PropertyCollection.Find("LargeImages", false)) != null)
            imageList = (ImageList)property.GetValue(instance);

         if ((imageList != null) && (imageList.Images.Count > imageIndex) && (imageIndex >= 0)) 
         {
            image = imageList.Images[imageIndex];
         }

         if (imageIndex < 0 || image == null)
         {
            pe.Graphics.DrawLine(Pens.Black, pe.Bounds.X + 1, pe.Bounds.Y + 1,
               pe.Bounds.Right - 1, pe.Bounds.Bottom - 1);
            pe.Graphics.DrawLine(Pens.Black, pe.Bounds.Right - 1, pe.Bounds.Y + 1,
               pe.Bounds.X + 1, pe.Bounds.Bottom - 1);
         }
         else
         {
            pe.Graphics.DrawImage(image, pe.Bounds);
         }
      }

        /// <summary>
        /// Draw a preview of the <see cref="ColorPair"/>
        /// </summary>
        /// <param name="e">The paint event args providing the <see cref="Graphics"/> and bounding
        /// rectangle</param>
        public override void PaintValue(PaintValueEventArgs e)
        {
            ColorPair colorPair = (ColorPair)e.Value ;

            using ( SolidBrush b = new SolidBrush(colorPair.Background)) {
                e.Graphics.FillRectangle(b, e.Bounds);
            }

            // Draw the text "ab" using the Foreground/Background values from the ColorPair
            using(SolidBrush b = new SolidBrush(colorPair.Foreground)) {
                using(Font f = new Font("Arial",6)) {
                    RectangleF temp = new RectangleF(e.Bounds.Left,e.Bounds.Top,e.Bounds.Height,e.Bounds.Width) ;
                    temp.Inflate(-2,-2) ;

                    // Set up how we want the text drawn
                    StringFormat format = new StringFormat(StringFormatFlags.FitBlackBox | StringFormatFlags.NoWrap) ;
                    format.Trimming = StringTrimming.EllipsisCharacter ;
                    format.Alignment = StringAlignment.Center ;
                    format.LineAlignment = StringAlignment.Center ;

                    // save the Smoothing mode of the Graphics object so we can restore it
                    SmoothingMode saveMode = e.Graphics.SmoothingMode ;
                    e.Graphics.SmoothingMode = SmoothingMode.AntiAlias ;
                    e.Graphics.DrawString("ab",f,b,temp,format) ;
                    e.Graphics.SmoothingMode = saveMode ;
                }
            }
        }

		public override void PaintValue(PaintValueEventArgs e)
		{
			WebControl control = e.Context.Instance as WebControl;

			// Fills the left rectangle with a color.
			e.Graphics.FillRegion(new SolidBrush(control.BackColor), new Region(e.Bounds));
		}

 public override void PaintValue(PaintValueEventArgs e)
 {
     if (e.Value is string && !string.IsNullOrEmpty((string)e.Value))
     {
         e.Graphics.DrawImage(global::Seal.Properties.Resources.error, 3, 0, 16, 16);
     }
 }

        public override void PaintValue(PaintValueEventArgs e)
        {
            var ts = (TextStyle) e.Value;
            using (var b = new SolidBrush(ts.BackColor))
            {
                e.Graphics.FillRectangle(b, e.Bounds);
            }

            FontStyle fs = FontStyle.Regular;
            if (ts.Bold)
                fs |= FontStyle.Bold;
            if (ts.Italic)
                fs |= FontStyle.Italic;
            if (ts.Underline)
                fs |= FontStyle.Underline;

            var f = new Font("arial", 8f, fs);

            using (var b = new SolidBrush(ts.ForeColor))
            {
                e.Graphics.DrawString("abc", f, b, e.Bounds);
            }

            f.Dispose();
        }

		/// <summary>
		/// Draw a preview of the <see cref="GradientColor"/>
		/// </summary>
		/// <param name="e">The paint event args providing the <see cref="Graphics"/> and bounding
		/// rectangle</param>
		public override void PaintValue(PaintValueEventArgs e) {
			GradientColor gradientColor = (GradientColor)e.Value ;
			using ( LinearGradientBrush b = gradientColor.GetBrush(e.Bounds,LinearGradientMode.Horizontal)) 
			{
				e.Graphics.FillRectangle(b, e.Bounds);
			}
		}

        public override void PaintValue(PaintValueEventArgs e)
        {
            if (!(e.Context.Instance is KrbTabControl)) return;
            var parent = (KrbTabControl)e.Context.Instance;
            var caption = (ButtonsCaption)e.Value;

            using (var brush = new LinearGradientBrush(e.Bounds, parent.GradientCaption.InactiveCaptionColorStart, parent.GradientCaption.InactiveCaptionColorEnd, parent.GradientCaption.CaptionGradientStyle))
            {
                var bl = new Blend(2) { Factors = new[] { 0.1F, 1.0F }, Positions = new[] { 0.0F, 1.0F } };
                brush.Blend = bl;
                e.Graphics.FillRectangle(brush, e.Bounds);

                Image captionDropDown = Resources.DropDown;
                using (var attributes = new ImageAttributes())
                {
                    var map = new[]
                    {
                        new ColorMap {OldColor = Color.White, NewColor = Color.Transparent},
                        new ColorMap {OldColor = Color.Black, NewColor = caption.InactiveCaptionButtonsColor}
                    };

                    attributes.SetRemapTable(map);

                    var rect = e.Bounds;
                    rect.Inflate(-3, 0);
                    e.Graphics.DrawImage(captionDropDown, rect, 0, 0, captionDropDown.Width, captionDropDown.Height, GraphicsUnit.Pixel, attributes);
                }
            }
        }

        /// <summary>
        /// Paints a representation of the value of an object using the specified <see cref="T:System.Drawing.Design.PaintValueEventArgs"/>.
        /// </summary>
        /// <param name="e">A <see cref="T:System.Drawing.Design.PaintValueEventArgs"/> that indicates what to paint and where to paint it.</param>
        public override void PaintValue(PaintValueEventArgs e)
        {
            e.Graphics.SmoothingMode = SmoothingMode.HighQuality;
            e.Graphics.InterpolationMode = InterpolationMode.HighQualityBilinear;

            Point center = new Point
            {
                X = e.Bounds.Width / 2,
                Y = e.Bounds.Height / 2
            };

            var backgroundBrush = Brushes.SteelBlue;
            var circleBrush = Brushes.White;
            var centerBrush = Brushes.Black;
            var anglePen = new Pen(Brushes.Red, 1f);

            // Fill background and ellipse and center point...
            e.Graphics.FillRectangle(backgroundBrush, e.Bounds.X, e.Bounds.Y, e.Bounds.Width, e.Bounds.Height);
            e.Graphics.FillEllipse(circleBrush, e.Bounds.X + 1, e.Bounds.Y + 1, e.Bounds.Width - 3, e.Bounds.Height - 3);
            e.Graphics.FillEllipse(centerBrush, center.X + e.Bounds.X - 1, center.Y + e.Bounds.Y - 1, 3, 3);

            // Draw line along the current Angle...
            float radians = (float)e.Value;

            e.Graphics.DrawLine(anglePen, center.X + e.Bounds.X, center.Y + e.Bounds.Y,
                e.Bounds.X + (center.X + (int)((float)center.X * Calculator.Cos(radians))),
                e.Bounds.Y + (center.Y + (int)((float)center.Y * Calculator.Sin(radians))));
        }

        public override void PaintValue(PaintValueEventArgs e)
        {
            var val = (bool?) e.Value;

            ControlPaint.DrawCheckBox(e.Graphics, e.Bounds,
                (val ?? false) ? ButtonState.Checked : ButtonState.Normal);
        }

 public override void PaintValue(PaintValueEventArgs e)
 {
     Graphics g = e.Graphics;
     GradientInfo gradient = (GradientInfo)e.Value;
     gradient.Draw(g, e.Bounds);
     g.DrawRectangleProper(Pens.Black, e.Bounds);
 }

 public override void PaintValue(PaintValueEventArgs e)
 {
     Hatcher hatch = e.Value as Hatcher;
     using (HatchBrush brush = new HatchBrush(hatch.HatchType, hatch.ForeColor, hatch.BackColor))
     {
         e.Graphics.FillRectangle(brush, e.Bounds);
     }
 }

 /// <summary>
 /// Draw a representation of our value
 /// </summary>
 public override void PaintValue(PaintValueEventArgs e)
 {
     IBrushData bd = e.Value as IBrushData;
     if (bd == null)
         base.PaintValue(e);
     else
         e.Graphics.FillRectangle(BlockFormat.PrepareBrushForDrawing(bd.GetBrush(), e.Bounds), e.Bounds);
 }

 public override void PaintValue(PaintValueEventArgs e)
 {
     if (this.innerEditor != null)
     {
         this.innerEditor.PaintValue(e);
     }
     base.PaintValue(e);
 }

 public override void PaintValue(PaintValueEventArgs e)
 {
     if ((e.Value as DirectoryInfo).Exists)
         e.Graphics.DrawImage(Properties.Resources.Folder.ToBitmap(),
             e.Bounds);
     else
         e.Graphics.DrawImage(Properties.Resources.FolderBad.ToBitmap(),
             e.Bounds);
 }

 public override void PaintValue(PaintValueEventArgs e)
 {
     if (e.Value is OpenTK.Graphics.Color4)
     {
         var col = (OpenTK.Graphics.Color4)e.Value;
         base.PaintValue(new PaintValueEventArgs(e.Context, Color.FromArgb(col.ToArgb()), e.Graphics, e.Bounds));
     }
     base.PaintValue(e);
 }

 public override void PaintValue(PaintValueEventArgs pe)
 {
     try
     {
         Color c = Color.FromArgb(((MyColor)pe.Value).R, ((MyColor)pe.Value).G, ((MyColor)pe.Value).B);
         Brush br = new SolidBrush(c);
         pe.Graphics.FillRectangle(br, pe.Bounds);
     }
     catch { }
 }