protected void DrawBackground(Graphics g, DrawState state)
 {
     Rectangle rc = ClientRectangle;
     // Draw background
     if (state == DrawState.Normal || state == DrawState.Disable)
     {
         g.FillRectangle(new SolidBrush(SystemColors.Control), rc);
         using (SolidBrush rcBrush = state == DrawState.Disable ?
             new SolidBrush(SystemColors.ControlDark) :
             new SolidBrush(SystemColors.ControlDarkDark))
         {
             // Draw border rectangle
             g.DrawRectangle(new Pen(rcBrush), rc.Left, rc.Top, rc.Width - 1, rc.Height - 1);
         }
     }
     else if ( state == DrawState.Hot || state == DrawState.Pressed  )
     {
         // Erase whaterver that was there before
         if ( state == DrawState.Hot )
             g.FillRectangle(new SolidBrush(ColorUtil.VSNetSelectionColor), rc);
         else
             g.FillRectangle(new SolidBrush(ColorUtil.VSNetPressedColor), rc);
         // Draw border rectangle
         g.DrawRectangle(SystemPens.Highlight, rc.Left, rc.Top, rc.Width-1, rc.Height-1);
     }
 }

 protected override void OnLostFocus(EventArgs e)
 {
     // Set state to Normal
       base.OnLostFocus(e);
       drawState = DrawState.Normal;
       Invalidate();
 }

        protected void DrawBackground( Graphics g, DrawState state )
        {
            Rectangle rc = ClientRectangle;

              // Draw background
              if( state == DrawState.Normal || state == DrawState.Disable )
              {
            g.FillRectangle( SystemBrushes.Control, rc );

            Pen p = ( state == DrawState.Disable ) ? SystemPens.ControlDark : SystemPens.ControlDarkDark;

            // Draw border rectangle
            g.DrawRectangle( p, rc.Left, rc.Top, rc.Width-1, rc.Height-1);

              }
              else if( state == DrawState.Hot || state == DrawState.Pressed  )
              {
            // Erase whaterver that was there before
            if ( state == DrawState.Hot )
              g.FillRectangle( ColorUtil.VSNetSelectionBrush, rc );
            else
              g.FillRectangle( ColorUtil.VSNetPressedBrush, rc );

            // Draw border rectangle
            g.DrawRectangle( SystemPens.Highlight, rc.Left, rc.Top, rc.Width-1, rc.Height-1 );
              }
        }

 void Start()
 {
     _drawStates = new DrawState[_pinchDetectors.Length];
       for (int i = 0; i < _pinchDetectors.Length; i++) {
     _drawStates[i] = new DrawState(this);
       }
 }

 //=====================================================================
 /// <summary>Constructor</summary>
 /// <param name="graphics">The graphics context</param>
 /// <param name="state">The drawing state of the item</param>
 /// <param name="offset">The image offset if scrolled</param>
 /// <param name="drawFocus">A flag indicating whether or not to draw the focus rectangle on return</param>
 public DrawImageEventArgs(Graphics graphics, DrawState state, Point offset, bool drawFocus)
 {
     this.Graphics = graphics;
     this.DrawState = state;
     this.ImageOffset = offset;
     this.DrawFocus = drawFocus;
 }

        public void ChangeDrawState(DrawState drawState, int id)
        {
            //選択できる範囲外だったら何もせずに終了
            if (!CanChangeDrawState(drawState, id)) return;

            switch (drawState)
            {
                case DrawState.MapChip:
                    MapChipPalletViewModel.DrawMapState.Set(id);
                    ObjectChipPalletViewModel.SelectCancel();
                    _current = MapChipPalletViewModel;
                    break;

                case DrawState.ObjChip:
                    ObjectChipPalletViewModel.DrawObjectState.Set(id);
                    MapChipPalletViewModel.SelectCancel();
                    _current = ObjectChipPalletViewModel;
                    break;

                case DrawState.Empty:
                    //何もしない
                    break;
                default:
                    throw new ArgumentOutOfRangeException("drawState");
            }
        }

 protected override void OnMouseEnter(EventArgs e)
 {
     // Set state to hot
       base.OnMouseEnter(e);
       drawState = DrawState.Hot;
       Invalidate();
 }

		protected override IShader BindShader(DrawState state, bool maskOnly)
		{
			Xen.Ex.Graphics2D.Statistics.DrawGraphLine shader = state.GetShader<Xen.Ex.Graphics2D.Statistics.DrawGraphLine>();

			if (dirty)
			{
				float x = widthScale;
				for (int i = 0; i < graphData.Length; i++)
				{
					int index = (i + this.index) % graphData.Length;
					float good = 0;

					if (goodValue != 0)
					{
						good = values[index];
						good = (good - Math.Abs(goodValue)) / goodValue;
					}
					graphData[i] = new Vector4(x, values[index] * maxValueInv, 0, good);
					x += widthScale;
				}
				dirty = false;
			}

			shader.GraphLine = this.graphData;

			return shader;
		}

 protected override void OnGotFocus(EventArgs e)
 {
     // Set state to Hot
       base.OnGotFocus(e);
       drawState = DrawState.Hot;
       Invalidate();
 }

		/// <summary>
		/// Begin the modifier (This method is called by the DrawTarget)
		/// </summary>
		/// <param name="state"></param>
		public void Begin(DrawState state)
		{
			enabledBuffer = enabled;
			this.cameras = state.Camera;

			if (enabledBuffer)
				state.Cullers.PushPostCuller(this);
		}

 public MatrixCalc(MatrixOp op, MatrixSource provider, MatrixSource source, DrawState state)
 {
     #if DEBUG
     this.state = state;
     #endif
     this.op = op;
     this.provider = provider;
     this.source = source;
 }

        protected void DrawButtonState(Graphics g, DrawState state)
        {
            DrawBackground(g, state);
            Rectangle rc = ClientRectangle;

            bool hasText = false;
            bool hasImage = Image != null;
            Size textSize = new Size(0,0);
            if ( Text != string.Empty && Text != "" )
            {
                hasText = true;
                textSize = TextUtil.GetTextSize(g, Text, Font);
            }

            int imageWidth = 0;
            int imageHeight = 0;
            if ( hasImage )
            {
                SizeF sizeF = Image.PhysicalDimension;
                imageWidth = (int)sizeF.Width;
                imageHeight = (int)sizeF.Height;
                // We are assuming that the button image is smaller than
                // the button itself
                if ( imageWidth > rc.Width || imageHeight > rc.Height)
                {
                    Debug.WriteLine("Image dimensions need to be smaller that button's dimension...");
                    return;
                }
            }

            int x, y;
            if ( hasText && !hasImage )
            {
                // Text only drawing
                x = (Width - textSize.Width)/2;
                y = (Height - textSize.Height)/2;
                DrawText(g, Text, state, x, y);
            }
            else if ( hasImage && !hasText )
            {
                // Image only drawing
                x = (Width - imageWidth)/2;
                y = (Height - imageHeight)/2;
                DrawImage(g, state, Image, x, y);
            }
            else
            {
                // Text and Image drawing
                x = (Width - textSize.Width - imageWidth -2)/2;
                y = (Height - imageHeight)/2;
                DrawImage(g, state, Image, x, y);
                x += imageWidth + 2;
                y = (Height - textSize.Height)/2;
                DrawText(g, Text, state, x, y);
            }
        }

 protected override void OnMouseLeave(EventArgs e)
 {
   // Set state to Normal
   base.OnMouseLeave(e);
   if ( !ContainsFocus )
   {
     drawState = DrawState.Normal;
     Invalidate();
   }
 }

        protected void DrawButtonState( Graphics g, DrawState state )
        {
            DrawBackground( g, state );
              Rectangle rc = ClientRectangle;
              Rectangle rcText = Rectangle.Inflate( ClientRectangle, -1, -1 );

              // draw Image
              if( Image != null )
              {
            SizeF sizeF   = Image.PhysicalDimension;
            int imgWidth  = (int)sizeF.Width;
            int imgHeight = (int)sizeF.Height;

            StringAlignment imgVAlign = GetVerticalAlign( ImageAlign );
            StringAlignment imgHAlign = GetHorizontalAlign( ImageAlign );

            int minWid = Width - 2, minHg = Height - 2;

            minWid = Math.Min( minWid, imgWidth );
            minHg = Math.Min( minHg, imgHeight );

            int xPos = Math.Min( minHg, minWid ) + 2;

            Bitmap bmp = new Bitmap( Image, new Size( minWid, minHg ) );

            int y = 1;

            if( imgVAlign == StringAlignment.Center )
            {
              y = ( Height - bmp.Height ) / 2;
            }
            else if( imgVAlign == StringAlignment.Far )
            {
              y = ( Height - bmp.Height - 1 );
            }

            switch( imgHAlign )
            {
              case StringAlignment.Near:
            rcText.X = xPos;  rcText.Width -= xPos;
            DrawImage( g, state, bmp, 2+(xPos-minWid)/2, y );
            break;

              case StringAlignment.Far:
            rcText.Width = rcText.Right - xPos;
            DrawImage( g, state, bmp, rcText.Right + (xPos-minWid)/2 - 2, y );
            break;
            }

            bmp.Dispose();
              }

              // draw Text
              DrawText( g, Text, state, rcText );
        }

        public override void Draw(IOutputCommand output, DrawState state, object param)
		{
            double I, J;
            if (!TryGetVariable('I', out I))
            {
                I = 0;
            }
            if (!TryGetVariable('J', out J))
            {
                J = 0;
            }

            output.DrawArc(this,param, Convert(Movetype, state), CalculatedStartPosition, CalculatedEndPosition,new Framework.Tools.Drawing.Point3D() { X=I, Y=J},true);
       }

			internal DrawStateProperties(DrawState state)
			{
				this.state = state;
				state.Application.Content.Add(this);
			}

		//call made by a particle drawer
		internal void DrawCallback(DrawState state, IParticleSystemDrawer particleDrawer)
		{
			if (systemLogic == null)
				throw new InvalidOperationException("Attempting to draw a ParticleSystem with unassigned ParticleSystemData Content");
			
			if (disposed)
				return;

			this.drawProc.MarkAsDrawn();

			//loop all the particle stores, and draw them all
			foreach (ParticleStore store in this.particleStore)
				store.ParticleProcessor.DrawCallback(state, particleDrawer, store.Count);
		}

		/// <summary>
		/// Warms the particle system (preloads any resources used)
		/// </summary>
		/// <param name="state"></param>
		public void Warm(DrawState state)
		{
			if (this.systemData == null)
				throw new InvalidOperationException("ParticleSystemData == null");
			foreach (ParticleStore store in this.particleStore)
				store.ParticleProcessor.Warm(state.Application);
		}

		/// <summary></summary>
		/// <param name="state"></param>
		protected internal override void End(DrawState state)
		{
			if (targets == null)
				throw new ObjectDisposedException("this");
		}

		/// <summary></summary>
		/// <param name="state"></param>
		protected internal override void Begin(DrawState state)
		{
			if (targets == null)
				throw new ObjectDisposedException("this");

			for (int i = 0; i < targets.Length; i++)
			{
				targets[i].Warm(state);
				if (targets[i].IsDisposed)
					throw new ObjectDisposedException("RenderTexture");
			}

#if XBOX360
			state.nonScreenRenderComplete = true;
#endif

			GraphicsDevice device = state.graphics;

			state.shaderSystem.ResetTextures();

			if (binding == null)
			{
				this.binding = new RenderTargetBinding[targets.Length];
				for (int i = 0; i < targets.Length; i++)
					binding[i] = new RenderTargetBinding(targets[i].GetRenderTarget2D());
			}

			device.SetRenderTargets(binding);
		}