public virtual void handleMouseMove(Point mouseLocation,
                                 PlayFrame frame,
                                 PitchScreenCoordConverter converter,
                                 VisualOverlay overlay)
 {
     //No op for normal tools.
 }
 public override void handleMouseDown(Point mouseLocation,
                                  PlayFrame frame,
                                  PitchScreenCoordConverter converter,
                                  VisualOverlay overlay)
 {
     //Noop
 }
        public override void handleMouseDown(Point mouseLocation, 
                                         PlayFrame frame,
                                         PitchScreenCoordConverter converter,
                                         VisualOverlay overlay)
        {
            if (mSelectedPlayer == null)
              {
            PointF pitchCoords = converter.screenToPitchCoords(mouseLocation);

            // No player is yet selected so attempt to find the one closest
            // to the selected spot.
            mSelectedPlayer = frame.GetClosestPlayer(pitchCoords,
                                                 Settings.Default.PlayerDiameter * 2.0f);

            if (mSelectedPlayer == null)
            {
              LinearMovement prevCut = frame.GetClosestCutEnd(pitchCoords,
                                                          Settings.Default.PlayerDiameter * 2.0f);

              if (prevCut != null &&
              prevCut != frame.DiscFrameMovement.ReceivingCut)
              {
            mSelectedPlayer = prevCut.Player;
            overlay.DrawingNewCut = true;
            overlay.CutStart = prevCut;
              }
            }
            else
            {
              overlay.DrawingNewCut = true;
              overlay.CutStart = frame.PlayerMovement[mSelectedPlayer][0];
            }
              }
        }
        public override void handleMouseUp(Point mouseLocation,
                                       PlayFrame frame,
                                       PitchScreenCoordConverter converter,
                                       VisualOverlay overlay)
        {
            frame.AddPlayer(new Player(Team.BLUE_TEAM,
                                 "",
                                 Settings.Default.DefaultPlayerSpeed,
                                 frame.GetNextFreePlayerId(Team.BLUE_TEAM)),
                      converter.screenToPitchCoords(mouseLocation));

              IsComplete = true;
              ModelChanged = true;
        }
 public override void handleMouseUp(Point mouseLocation, 
                                PlayFrame frame,
                                PitchScreenCoordConverter converter,
                                VisualOverlay overlay)
 {
     if (mSelectedPlayer != null)
       {
     frame.PlayerMovement[mSelectedPlayer].Add(
       new LinearMovement(converter.screenToPitchCoords(mouseLocation),
                          100,
                          mSelectedPlayer));
     IsComplete = true;
     ModelChanged = true;
       }
 }
        public override void handleMouseUp(Point mouseLocation, 
                                       PlayFrame frame,
                                       PitchScreenCoordConverter converter,
                                       VisualOverlay overlay)
        {
            PointF pitchCoords = converter.screenToPitchCoords(mouseLocation);

              Player closestPlayer = frame.GetClosestPlayer(pitchCoords,
                                                    Settings.Default.PlayerDiameter);

              if (closestPlayer != null)
              {
            frame.AddDisc(closestPlayer);

            IsComplete = true;
            ModelChanged = true;
              }
        }
        public override void handleMouseUp(Point mouseLocation, 
                                       PlayFrame frame,
                                       PitchScreenCoordConverter converter,
                                       VisualOverlay overlay)
        {
            PointF pitchCoords = converter.screenToPitchCoords(mouseLocation);

              if (mSelectedPlayer != null)
              {
            // This function doesn't necessarily create a trigger but regardless
            // we say that the tool is complete anyway.
            if (frame.MaybeCreateTrigger(pitchCoords,
                                     Settings.Default.PitchLength,
                                     mSelectedPlayer))
            {
              ModelChanged = true;
            }

            IsComplete = true;
              }
        }
        /// <summary>
        /// In order to move an item we catch the mouse down event to decide which
        /// thing has been selected. This function chooses either the selected
        /// cut, trigger or player.
        /// </summary>
        /// <param name="mouseLocation">Screen coordinates.</param>
        /// <param name="frame">Frame currently being designed.</param>
        /// <param name="converter">Used to convert from screen to pitch 
        /// coordinates.</param>
        public override void handleMouseDown(Point mouseLocation, 
                                         PlayFrame frame,
                                         PitchScreenCoordConverter converter,
                                         VisualOverlay overlay)
        {
            PointF pitchCoords = converter.screenToPitchCoords(mouseLocation);

              // Choose closest selected item.
              mSelectedPlayer = frame.GetClosestPlayer(pitchCoords,
                                               SELECTION_MAX_DISTANCE);
              mSelectedCut = frame.GetClosestCutEnd(pitchCoords,
                                              SELECTION_MAX_DISTANCE);
              mSelectedTrigger = frame.GetClosestTrigger(pitchCoords,
                                                 SELECTION_MAX_DISTANCE);
              mIsMovingDiscControlPoint = frame.IsNearControlPoint(pitchCoords,
                                                           SELECTION_MAX_DISTANCE);

              // Note that the ordering of priorities here MUST be the same as the
              // ordering on mouse up.
              if (mSelectedTrigger != null)
              {
            overlay.SelectedTrigger = mSelectedTrigger;
            overlay.TriggerPlayer = mSelectedTrigger.AffectedPlayer;
              }
              else if (mSelectedCut != null)
              {
            overlay.DrawingNewCut = false;
            overlay.CutStart = mSelectedCut;
              }
              else if (mSelectedPlayer != null)
              {
            overlay.SelectedPlayer = mSelectedPlayer;
              }
              else if (mIsMovingDiscControlPoint)
              {
            overlay.MovingDiscControlPoint = true;
              }
        }
        public override void handleMouseUp(Point mouseLocation,
                                       PlayFrame frame,
                                       PitchScreenCoordConverter converter,
                                       VisualOverlay overlay)
        {
            PointF pitchCoords = converter.screenToPitchCoords(mouseLocation);

              LinearMovement cut = frame.GetClosestDiscFlightPoint(pitchCoords,
                                                           Settings.Default.PlayerDiameter);

              if (cut == null)
              {
            // The user has clicked away from any cut. They may want the disc to
            // go to ground so check before setting it.
            DialogResult result = MessageBox.Show(
              "You have not selected a cut to throw to, would you like the " +
              " disc to go here anyway",
              "Throw disc to ground?",
              MessageBoxButtons.YesNo);

            if (result == DialogResult.Yes)
            {
              frame.DiscFrameMovement.AbsoluteFlightPath = pitchCoords;
              frame.DiscFrameMovement.HasMoved = true;

              IsComplete = true;
              ModelChanged = true;
            }
              }
              else
              {
            frame.DiscFrameMovement.ReceivingCut = cut;
            frame.DiscFrameMovement.HasMoved = true;
            IsComplete = true;
            ModelChanged = true;
              }
        }
        /// <summary>
        /// Called whenever the underlying frame changes to redraw the frame.
        /// </summary>
        public void DrawFrame(PlayFrame frame, 
                          Graphics display, 
                          PitchScreenCoordConverter converter,
                          VisualOverlay overlay,
                          Rectangle displayRectangle)
        {
            BufferedGraphicsContext currentContext;
              BufferedGraphics myBuffer;
              currentContext = BufferedGraphicsManager.Current;
              myBuffer = currentContext.Allocate(display,
                                         displayRectangle);
              myBuffer.Graphics.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;
              myBuffer.Graphics.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
              myBuffer.Graphics.Clear(mBackColor);

              // Draw the pitch itself.
              DrawPitch(myBuffer.Graphics, converter);

              // This moves items around based on what the user is doing.
              // e.g. If a user is dragging a cut at the moment it adds a new cut for
              // the given player.
              PlayFrame adjustableFrame = FrameRenderer.AdjustFrameForOverlay(frame,
                                                                      overlay,
                                                                      converter);

              foreach (Player player in adjustableFrame.PlayerMovement.Keys)
              {
            List<LinearMovement> playerMoves = adjustableFrame.PlayerMovement[player];

            if (playerMoves.Count > 0)
            {

              DrawPlayer(player,
                     playerMoves[0].FinalPosition,
                     myBuffer.Graphics,
                     converter,
                     false);

              if (playerMoves.Count > 1)
              {
            List<Point> cutLocations = new List<Point>();

            foreach (LinearMovement playerMove in playerMoves)
            {
              cutLocations.Add(converter.pitchToScreenCoords(playerMove.FinalPosition));
            }

            myBuffer.Graphics.DrawLines(mCutPen, cutLocations.ToArray<Point>());
              }
            }
              }

              foreach (Trigger trigger in adjustableFrame.Triggers)
              {
            DrawTrigger(myBuffer.Graphics, trigger, converter);
              }

              // Draw the disc after the players because the sprite sits on top of the
              // player sprite who is holding it.
              if (adjustableFrame.DiscFrameMovement.Thrower != null)
              {
            DrawDisc(myBuffer.Graphics,
                 adjustableFrame.DiscFrameMovement.StartPosition(),
                 converter);

            if (adjustableFrame.DiscFrameMovement.HasMoved)
            {
              DrawDiscFlight(myBuffer.Graphics,
                         adjustableFrame.DiscFrameMovement.StartPosition(),
                         adjustableFrame.DiscFrameMovement.ControlPoint,
                         adjustableFrame.DiscFrameMovement.EndPosition(),
                         converter);
            }
              }
              else if (overlay.PlacingDisc)
              {
            // The mouse location is stored in the overlay but we need to pass the
            // pitch coordinates to the drawing function.
            DrawDisc(myBuffer.Graphics,
                 converter.screenToPitchCoords(overlay.MouseLocation),
                 converter);
              }

              myBuffer.Render();
              myBuffer.Dispose();
        }
        /// <summary>
        /// There are two components to the drawing. The first is the data model
        /// which is represented by a single PlayFrame.
        /// 
        /// The second is a visual overlay indicating what the user is current 
        /// doing.
        /// 
        /// This function takes the frame and 'applies' the overlay to it by
        /// creating a deep copy and then moving/adding items as required by
        /// the overlay. For this to work we need to be able to uniquely
        /// reference items in a playmodel by an id (as their refs change on a
        /// deep copy).
        /// </summary>
        /// <param name="frame"></param>
        /// <param name="overlay"></param>
        /// <param name="converter"></param>
        /// <returns></returns>
        private static PlayFrame AdjustFrameForOverlay(PlayFrame frame, 
                                                   VisualOverlay overlay, 
                                                   PitchScreenCoordConverter converter)
        {
            // Take a deep copy of the frame so that we can adjust it based on what
              // visual overlay is required.
              PlayFrame adjustableFrame = frame.Clone();

              PointF pitchCoords = converter.screenToPitchCoords(overlay.MouseLocation);

              // First move any players who need to be.
              if (overlay.SelectedPlayer != null)
              {
            Player movedPlayer = adjustableFrame.GetPlayerById(overlay.SelectedPlayer.UniqueId);
            if (movedPlayer != null)
            {
              adjustableFrame.PlayerMovement[movedPlayer][0].FinalPosition = pitchCoords;
            }
            else
            {
              adjustableFrame.AddPlayer(overlay.SelectedPlayer, pitchCoords);
            }
              }

              // Either a new cut is being drawn or a cut is being moved.
              if (overlay.CutStart != null)
              {
            if (overlay.DrawingNewCut)
            {
              Player cuttingPlayer = adjustableFrame.GetPlayerById(overlay.CutStart.Player.UniqueId);

              adjustableFrame.PlayerMovement[cuttingPlayer].Add(
                                           new LinearMovement(pitchCoords,
                                                              100,
                                                              cuttingPlayer));
            }
            else
            {
              LinearMovement movedCut = adjustableFrame.GetCutById(overlay.CutStart.UniqueId);

              adjustableFrame.ReplaceCut(movedCut, pitchCoords);
            }
              }

              // Check if the user is drawing the disc movement at the moment.
              if (overlay.DrawingDiscMovement)
              {
            adjustableFrame.DiscFrameMovement.AbsoluteFlightPath = pitchCoords;
            adjustableFrame.DiscFrameMovement.HasMoved = true;
              }

              if (overlay.MovingDiscControlPoint)
              {
            adjustableFrame.DiscFrameMovement.ControlPoint = pitchCoords;
              }

              // If there is a trigger being moved then the selected trigger must have
              // it's position updated.
              if (overlay.SelectedTrigger != null)
              {
            CutRatio closestCutPoint = adjustableFrame.GetClosestCutPoint(pitchCoords,
              sPitchLength,
              overlay.SelectedTrigger.AffectedPlayer);

            if (closestCutPoint != null)
            {
              Trigger adjustedTrigger = adjustableFrame.GetTriggerById(overlay.SelectedTrigger.UniqueId);

              if (adjustedTrigger != null)
              {
            adjustedTrigger.CausingCutRatio = closestCutPoint;
              }
            }
              }
              else if (overlay.PlacingTrigger)
              {
            adjustableFrame.MaybeCreateTrigger(pitchCoords,
                                           sPitchLength,
                                           overlay.TriggerPlayer);
              }

              return adjustableFrame;
        }
 public override void Cancel(VisualOverlay overlay, PlayFrame frame)
 {
 }
 public override void Cancel(VisualOverlay overlay, PlayFrame frame)
 {
     mToolPicture.Visible = true;
 }
        /// <summary>
        /// We capture the mouse up event and use it to place whatever it was that
        /// was selected on the mouse down event. If nothing was selected this does
        /// nothing. 
        /// </summary>
        /// <param name="mouseLocation"></param>
        /// <param name="frame"></param>
        /// <param name="converter"></param>
        public override void handleMouseUp(Point mouseLocation,
                                       PlayFrame frame,
                                       PitchScreenCoordConverter converter,
                                       VisualOverlay overlay)
        {
            PointF pitchCoords = converter.screenToPitchCoords(mouseLocation);

              if (mSelectedTrigger != null)
              {
            // If we are moving a trigger then only move it if the position it is
            // being placed is valid.
            if (frame.MaybeCreateTrigger(pitchCoords,
                                     SELECTION_MAX_DISTANCE,
                                     mSelectedTrigger.AffectedPlayer))
            {
              frame.RemoveTrigger(mSelectedTrigger);
              ModelChanged = true;
            }
              }
              else if (mSelectedPlayer != null)
              {
            frame.PlayerMovement[mSelectedPlayer][0].FinalPosition = pitchCoords;
            ModelChanged = true;
              }
              else if (mSelectedCut != null)
              {
            mSelectedCut.FinalPosition = pitchCoords;
            ModelChanged = true;
              }
              else if (mIsMovingDiscControlPoint)
              {
            frame.DiscFrameMovement.ControlPoint = pitchCoords;
            ModelChanged = true;
              }

              // Regardless of whether anything moved the move tool is complete on
              // mouse up.
              mSelectedCut = null;
              mSelectedPlayer = null;
              mSelectedTrigger = null;
              IsComplete = true;
        }
 public abstract void handleMouseUp(Point mouseLocation,
                                PlayFrame frame,
                                PitchScreenCoordConverter converter,
                                VisualOverlay overlay);
 public abstract void Cancel(VisualOverlay overlay, PlayFrame frame);