/// <summary>
 ///    <para>
 ///       Initializes a new instance of the Rectangle class with the specified location
 ///       and size.
 ///    </para>
 /// </summary>
 public Rectangle(Point location, Size size)
 {
     _x = location.X;
     _y = location.Y;
     _width = size.Width;
     _height = size.Height;
 }

        protected override void OnMouseDown(MouseEventArgs e)
        {
            base.OnMouseDown(e);
            clickPoint = Cursor.Position;
            this.Capture = true;

        }

 public MarkerImage(string path, Size size, Point point, Point anchor)
 {
     Path = System.Web.VirtualPathUtility.ToAbsolute(path);
     Size = size;
     Point = point;
     Anchor = anchor;
 }

 protected BaseActor(ILevelInfo info)
 {
     Info = info;
       Position = new Point(0, 0);
       IsAlive = true;
       CanDrop = false;
 }

 private void initKalman()
 {
     last = lastEst = new System.Drawing.Point();
     kf = new Kalman(kfData.state,kfData.transitionMatrix, kfData.measurementMatrix, 
         kfData.processNoise, kfData.measurementNoise);
     kf.ErrorCovariancePost = kfData.errorCovariancePost;
 }

 internal static IComeDirection GetComeDirection(Point user, Point ball)
 {
     try
     {
         if (user.X == ball.X && user.Y - 1 == ball.Y)
             return IComeDirection.Down;
         if (user.X + 1 == ball.X && user.Y - 1 == ball.Y)
             return IComeDirection.DownLeft;
         if (user.X + 1 == ball.X && user.Y == ball.Y)
             return IComeDirection.Left;
         if (user.X + 1 == ball.X && user.Y + 1 == ball.Y)
             return IComeDirection.UpLeft;
         if (user.X == ball.X && user.Y + 1 == ball.Y)
             return IComeDirection.Up;
         if (user.X - 1 == ball.X && user.Y + 1 == ball.Y)
             return IComeDirection.UpRight;
         if (user.X - 1 == ball.X && user.Y == ball.Y)
             return IComeDirection.Right;
         if (user.X - 1 == ball.X && user.Y - 1 == ball.Y)
             return IComeDirection.DownRight;
         return IComeDirection.Null;
     }
     catch
     {
         return IComeDirection.Null;
     }
 }

        private void glCanvas1_MouseDown(object sender, MouseEventArgs e)
        {
            this.lastMousePosition = e.Location;
            this.lastMouseDownPosition = e.Location;

            if (e.Button == System.Windows.Forms.MouseButtons.Right)
            {
                //// operate camera
                //rotator.SetBounds(this.glCanvas1.Width, this.glCanvas1.Height);
                //rotator.MouseDown(e.X, e.Y);
            }
            else if (e.Button == System.Windows.Forms.MouseButtons.Left)
            {
                // move vertex
                if (pickedGeometry != null)
                {
                    ViewPort viewPort = pickedGeometry.FromViewPort;
                    ICamera camera = viewPort.Camera;
                    var dragParam = new DragParam(
                        camera.GetPerspectiveProjectionMatrix(),
                        camera.GetViewMatrix(),
                        viewPort.Rect.ToViewport(),
                        new Point(e.X, glCanvas1.Height - e.Y - 1));
                    dragParam.pickedVertexIds.AddRange(pickedGeometry.VertexIds);
                    this.dragParam = dragParam;
                }
            }
        }

 public Rectangle GetBounds(Point itemLocation, Size itemSize)
 {
     return new Rectangle((itemLocation.X + itemSize.Width) - locationFromRight.X,
                          itemLocation.Y,
                          size.Width,
                          size.Height);
 }

 public Rectangle(Point p, Size s)
 {
    X = p.X;
    Y = p.Y;
    Width = s.Width;
    Height = s.Height;
 }

 private void PrintNew(int x, int y)
 {
     var point = new Point(x * scale, y * scale);
     var size = new Size(scale, scale);
     var rectangle = new Rectangle(point, size);
     graphics.FillEllipse(Brushes.Black, rectangle);
 }

 /// <summary>
 /// Determines the editing mode from input position.</summary>
 /// <param name="p">Input position point</param>
 public override void SetEditingMode(Point p)
 {
     if (Bounds.Contains(p))
         EditingMode = EditMode.ByClick;
     else
         EditingMode = EditMode.None;
 }

 /// <summary>
 /// ポイントがD＆Dするとサイズが変更されるエリア内にあるかどうかを判定します。
 /// </summary>
 public bool ContainsSizeChangeArea(Point p)
 {
     return getTop().Contains(p) ||
         getBottom().Contains(p) ||
         getLeft().Contains(p) ||
         getRight().Contains(p);
 }

 private void BaseMain_MouseDown(object sender, MouseEventArgs e)
 {
   if (e.Button != MouseButtons.Left)
     return;
   this.mouseOff = new Point(-e.X, -e.Y);
   this.leftFlag = true;
 }

 public void ConvertToWindowsPointTest()
 {
     var point = new Point(10, 10);
     System.Windows.Point winPoint = point.ConvertToWindowsPoint();
     Assert.That(winPoint.X, Is.EqualTo(10));
     Assert.That(winPoint.Y, Is.EqualTo(10));
 }

 public void ClickSaveConnection()
 {
     WpfWindow theWindow = GetNewServerWindow();
     Point p = new Point(theWindow.BoundingRectangle.Left + 300, theWindow.BoundingRectangle.Top + 275);
     Mouse.Move(p);
     Mouse.Click();
 }

 private void PrintWay(List<Location> loc, Color color, RadarForm form)
 {
     if (loc != null)
     {
         PointF[] points;
         Point tempP;
         Location ld;
         if (loc.Count != 0)
         {
             points = new PointF[loc.Count + 1];
             int i = 0;
             foreach (Location lo in loc)
             {
                 form.PrintCircle(color, form.OffsetY(lo.Y, ObjectManager.MyPlayer.Location.Y),
                                  form.OffsetX(lo.X, ObjectManager.MyPlayer.Location.X), "");
                 tempP = new Point(form.OffsetY(lo.Y, ObjectManager.MyPlayer.Location.Y),
                                   form.OffsetX(lo.X, ObjectManager.MyPlayer.Location.X));
                 points[i] = tempP;
                 i++;
             }
             ld = loc[0];
             tempP = new Point(form.OffsetY(ld.Y, ObjectManager.MyPlayer.Location.Y),
                               form.OffsetX(ld.X, ObjectManager.MyPlayer.Location.X));
             points[i] = tempP;
             form.ScreenDc.DrawLines(new Pen(_colorWaypoints), points);
         }
     }
 }

        public PauseScreen(XElement reader, string basePath)
        {
            weapons = new List<PauseWeaponInfo>();
            inventory = new List<InventoryInfo>();

            XElement changeNode = reader.Element("ChangeSound");
            if (changeNode != null) ChangeSound = SoundInfo.FromXml(changeNode, basePath);

            XElement soundNode = reader.Element("PauseSound");
            if (soundNode != null) PauseSound = SoundInfo.FromXml(soundNode, basePath);

            XElement backgroundNode = reader.Element("Background");
            if (backgroundNode != null) Background = FilePath.FromRelative(backgroundNode.Value, basePath);

            foreach (XElement weapon in reader.Elements("Weapon"))
                weapons.Add(PauseWeaponInfo.FromXml(weapon, basePath));

            XElement livesNode = reader.Element("Lives");
            if (livesNode != null)
            {
                LivesPosition = new Point(livesNode.GetInteger("x"), livesNode.GetInteger("y"));
            }

            foreach (XElement inventoryNode in reader.Elements("Inventory"))
            {
                inventory.Add(InventoryInfo.FromXml(inventoryNode, basePath));
            }
        }

 public Zone(Point point1, Point point2, Point point3, Point point4)
 {
     Point1 = point1;
     Point2 = point2;
     Point3 = point3;
     Point4 = point4;
 }

 /// <summary>
 ///     清除所有GroupItem
 /// </summary>
 public void Clear()
 {
     Controls.Clear();
     _conditionCount = 0;
     _conditionPos = new Point(10, 0);
     AddGroupItem();
 }

 public bool IsPartOfRectangle(Point point)
 {
     if (Point1.Y >= point.Y && Point2.Y <= point.Y)
         if (point.X >= Point1.X && point.X <= Point3.X)
             return true;
     return false;
 }