Comment afficher le nouveau formulaire à la position actuelle du curseur de la souris?

Question

Voici le code:

private void hsMagnfier_OnMouseDown(object sender) 
{ 
    int x = mLastCursorPosition.X; 
    int y = mLastCursorPosition.Y; 
    MagnifierForm magnifier = new MagnifierForm(mConfiguration, System.Windows.Forms.Cursor.Position);//mLastCursorPosition); 
    magnifier.Show(); 
} 

Ce code ci-dessus est dans un Form que je peux faire glisser sur l'écran.

Ensuite, quand je clique sur une icône, elle fait magnifier.Show(); et la forme de la loupe est affichée là où se trouve la position actuelle de la souris.

Mais si je clique dessus encore maintenant la position de la nouvelle forme la loupe est dans mon centre Form1. Et pas où la souris position actuelle comme dans la première fois.

C'est peut-être le code MagnifierForm peut-être la première fois c'est dans la position actuelle de la souris mais dans la prochaine fois/s c'est au centre de Form1?

using System; 
using System.Collections.Generic; 
using System.ComponentModel; 
using System.Data; 
using System.Drawing; 
using System.Text; 
using System.Windows.Forms; 
using System.Drawing.Drawing2D; 
using System.IO; 
using System.Drawing.Imaging; 

namespace ScreenVideoRecorder 
{ 
    public partial class MagnifierForm : Form 
    { 

     public MagnifierForm(Configuration configuration, Point startPoint) 
     { 
      InitializeComponent(); 

      //--- My Init --- 
      mConfiguration = configuration; 
      FormBorderStyle = FormBorderStyle.None; 

      ShowInTaskbar = mConfiguration.ShowInTaskbar; 
      TopMost = mConfiguration.TopMostWindow; 
      Width = mConfiguration.MagnifierWidth; 
      Height = mConfiguration.MagnifierHeight; 

      // Make the window (the form) circular 
      GraphicsPath gp = new GraphicsPath(); 
      gp.AddEllipse(ClientRectangle); 
      Region = new Region(gp); 

      mImageMagnifier = Properties.Resources.magnifierGlass; 

      mTimer = new Timer(); 
      mTimer.Enabled = true; 
      mTimer.Interval = 20; 
      mTimer.Tick += new EventHandler(HandleTimer); 

      mScreenImage = new Bitmap(Screen.PrimaryScreen.Bounds.Width, 
            Screen.PrimaryScreen.Bounds.Height); 

      mStartPoint = startPoint; 
      mTargetPoint = startPoint; 

      if (mConfiguration.ShowInTaskbar) 
       ShowInTaskbar = true; 
      else 
       ShowInTaskbar = false; 
     } 

     protected override void OnShown(EventArgs e) 
     { 
      RepositionAndShow(); 
     } 

     private delegate void RepositionAndShowDelegate(); 

     private void RepositionAndShow() 
     { 
      if (InvokeRequired) 
      { 
       Invoke(new RepositionAndShowDelegate(RepositionAndShow)); 
      } 
      else 
      { 
       // Capture the screen image now! 
       Graphics g = Graphics.FromImage(mScreenImage); 
       g.CopyFromScreen(0, 0, 0, 0, new Size(mScreenImage.Width, mScreenImage.Height)); 
       g.Dispose();     

       if (mConfiguration.HideMouseCursor) 
        Cursor.Hide(); 
       else 
        Cursor = Cursors.Cross; 

       Capture = true; 

       if (mConfiguration.RememberLastPoint) 
       { 
        mCurrentPoint = mLastMagnifierPosition; 
        Cursor.Position = mLastMagnifierPosition; 
        Left = (int)mCurrentPoint.X - Width/2; 
        Top = (int)mCurrentPoint.Y - Height/2; 
       } 
       else 
       { 
        mCurrentPoint = Cursor.Position; 
       } 
       Show(); 
      } 
     } 

     void HandleTimer(object sender, EventArgs e) 
     { 
      float dx = mConfiguration.SpeedFactor * (mTargetPoint.X - mCurrentPoint.X); 
      float dy = mConfiguration.SpeedFactor * (mTargetPoint.Y - mCurrentPoint.Y); 

      if (mFirstTime) 
      { 
       mFirstTime = false; 

       mCurrentPoint.X = mTargetPoint.X; 
       mCurrentPoint.Y = mTargetPoint.Y; 

       Left = (int)mCurrentPoint.X - Width/2; 
       Top = (int)mCurrentPoint.Y - Height/2; 

       return; 
      } 

      mCurrentPoint.X += dx; 
      mCurrentPoint.Y += dy; 

      if (Math.Abs(dx) < 1 && Math.Abs(dy) < 1) 
      { 
       mTimer.Enabled = false; 
      } 
      else 
      { 
       // Update location 
       Left = (int)mCurrentPoint.X - Width/2; 
       Top = (int)mCurrentPoint.Y - Height/2; 
       mLastMagnifierPosition = new Point((int)mCurrentPoint.X, (int)mCurrentPoint.Y); 
      } 

      Refresh(); 
     } 


     protected override void OnMouseDown(MouseEventArgs e) 
     { 
      mOffset = new Point(Width/2 - e.X, Height/2 - e.Y); 
      mCurrentPoint = PointToScreen(new Point(e.X + mOffset.X, e.Y + mOffset.Y)); 
      mTargetPoint = mCurrentPoint; 
      mTimer.Enabled = true; 
     } 

     protected override void OnMouseUp(MouseEventArgs e) 
     { 
      if (mConfiguration.CloseOnMouseUp) 
      { 
       Close(); 
       mScreenImage.Dispose(); 
      } 

      Cursor.Show(); 
      Cursor.Position = mStartPoint;    
     } 

     protected override void OnMouseMove(MouseEventArgs e) 
     { 
      if (e.Button == MouseButtons.Left) 
      { 
       mTargetPoint = PointToScreen(new Point(e.X + mOffset.X, e.Y + mOffset.Y)); 
       mTimer.Enabled = true; 
      } 
     } 

     protected override void OnPaintBackground(PaintEventArgs e) 
     { 
      if (mConfiguration.DoubleBuffered) 
      { 
       // Do not paint background (required for double buffering)! 
      } 
      else 
      { 
       base.OnPaintBackground(e); 
      } 
     } 

     protected override void OnPaint(PaintEventArgs e) 
     { 
      if (mBufferImage == null) 
      { 
       mBufferImage = new Bitmap(Width, Height); 
      } 
      Graphics bufferGrf = Graphics.FromImage(mBufferImage); 

      Graphics g; 

      if (mConfiguration.DoubleBuffered) 
      { 
       g = bufferGrf; 
      } 
      else 
      { 
       g = e.Graphics; 
      } 

      if (mScreenImage != null) 
      { 
       Rectangle dest = new Rectangle(0, 0, Width, Height); 
       int w = (int)(Width/mConfiguration.ZoomFactor); 
       int h = (int)(Height/mConfiguration.ZoomFactor); 
       int x = Left - w/2 + Width/2; 
       int y = Top - h/2 + Height/2; 

       g.DrawImage(
        mScreenImage, 
        dest, 
        x, y, 
        w, h, 
        GraphicsUnit.Pixel); 
      } 

      if (mImageMagnifier != null) 
      { 
       g.DrawImage(mImageMagnifier, 0, 0, Width, Height); 
      } 

      if (mConfiguration.DoubleBuffered) 
      { 
       e.Graphics.DrawImage(mBufferImage, 0, 0, Width, Height); 
      }  
     } 


     //--- Data Members --- 
     #region Data Members 
     private Timer mTimer; 
     private Configuration mConfiguration; 
     private Image mImageMagnifier; 
     private Image mBufferImage = null; 
     private Image mScreenImage = null; 
     private Point mStartPoint; 
     private PointF mTargetPoint; 
     private PointF mCurrentPoint; 
     private Point mOffset; 
     private bool mFirstTime = true; 
     private static Point mLastMagnifierPosition = Cursor.Position; 
     #endregion 
    } 
} 

La première fois que le nouveau formulaire est la loupe apparaît là où mon cursour de la souris. La prochaine fois que je clique dessus, la forme de la loupe apparaît au centre de Form1 et non pas le curseur de la souris.

Pourquoi est-ce? Lorsque je clique sur l'icône à nouveau, il fait toujours le

System.Windows.Forms.Cursor.Position 

Encore une fois. Étrange.

Answer 1

Ok trouvé que la partie qui le faire est ici sous la forme Loupe:

mConfiguration.RememberLastPoint = false; 
if (mConfiguration.RememberLastPoint) 
{ 
    mCurrentPoint = mLastMagnifierPosition; 
    Cursor.Position = mLastMagnifierPosition; 
    Left = (int)mCurrentPoint.X - Width/2; 
    Top = (int)mCurrentPoint.Y - Height/2; 
} 
else 
{ 
    mCurrentPoint = Cursor.Position; 
} 

J'ajouté pour l'instant la ligne: mConfiguration.RememberLastPoint = false; qui a fait le travail pour l'instant.

Answer 2

Considérez vous avez deux formes - Master et Child

Si vous appelez des enfants de Maître sur l'événement MouseUp (par exemple), écrire le code dans MouseUp cas de Master forme

ChildForm obj=new ChildForm(); 
obj.pntLocation = new Point(Cursor.Position.X, Cursor.Position.Y); 
obj.ShowDialog(); 

Déclarez une variable à l'intérieur de l'enfant pour l'emplacement

public Point pntLocation; 

Configurer maintenant ion à l'intérieur du de Child

this.Location = pntLocation;