An improved drag-drop implementation with full positioning control

class Outline: Form
  {
      #region Attributes

      private static Outline outline = null;
      private Point m_Delta = new Point(0, 0);

      public Point Delta
      {
          get { return m_Delta; }
          set { m_Delta = value; }
      }
      #endregion

      #region Constructor
      // Constructor
        private Outline() 
        {
          // Set some properties to make this form a transparent black rectangle
          this.SuspendLayout();
          this.ClientSize = new System.Drawing.Size(0, 0);
          this.StartPosition = FormStartPosition.Manual;
          this.BackColor = Color.Black;
          this.Opacity = 0.4;          
          this.FormBorderStyle = FormBorderStyle.None;
          this.ShowInTaskbar = false;
          this.ControlBox = false;
          this.TopMost = true;         
          this.ResumeLayout(false);
          
        }
      #endregion

      #region Methods
            
      /// // Show
        static public void Show(Point location, Size size) {
          // Create a new object?
          if(outline == null) {
            outline = new Outline();
            outline.Show(); // Just to get the size correct at first use (.NET bug?). Try to remove this line...
          }
          // Set the location and size, then show the form
          //outline.Location = location; 
          outline.Location = new Point((location.X > 0 ? location.X : 0),
                                (location.Y > 0 ? location.Y : 0));
          outline.Delta = new Point((location.X < 0 ? location.X : 0),
                                (location.Y < 0 ? location.Y : 0));
          Size displaySize = new Size(outline.Delta.X + size.Width, outline.Delta.Y + size.Height);
          outline.Size = displaySize;
          outline.Show();
        }
        // Hide
        new static public void Hide() {
          if(outline != null) {
            // Since we hide the original Hide() method we need to do this...
            (outline as Control).Hide();
          }
        }

        // Resize
        new static public void Resize(Size size) {
          if(outline != null) {
              Size displaySize = new Size(outline.Delta.X + size.Width, outline.Delta.Y + size.Height);              
              (outline as Control).Size = displaySize;
            //(outline as Control).Size = size;
          }
        }

        // Move
        new static public void Move(Point location)
        {
          if(outline != null) {
            //(outline as Control).Location = point;

            
            Point originalDelta = outline.Delta;
            outline.Location = new Point((location.X > 0 ? location.X : 0),
                      (location.Y > 0 ? location.Y : 0));
            outline.Delta = new Point((location.X < 0 ? location.X : 0),
                                    (location.Y < 0 ? location.Y : 0));

            Point shift = new Point(outline.Delta.X - originalDelta.X,
                                      outline.Delta.Y - originalDelta.Y);

            Size displaySize = new Size((outline as Control).Size.Width + shift.X, (outline as Control).Size.Height + shift.Y);
            (outline as Control).Size = displaySize;
          }
        }
        #endregion

        private void InitializeComponent()
        {
            System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(Outline));
            this.SuspendLayout();
            // 
            // Outline
            // 
            resources.ApplyResources(this, "$this");
            this.Name = "Outline";
            this.SizeGripStyle = System.Windows.Forms.SizeGripStyle.Hide;
            this.ResumeLayout(false);

        }
  }  

// Handle mouse up; Perform a local move
private void userControl_MouseUp(object sender, MouseEventArgs mouseEventArgs) {
  ...
  // Unregister the mouse move handler
  (sender as Control).MouseMove -= new MouseEventHandler(userControl_MouseMove);
  ...
}

...
using System.Runtime.InteropServices;
...
[DllImport("user32.dll", EntryPoint="DestroyIcon")]
static extern bool DestroyIcon(IntPtr hIcon);
...
private Graphics cursorGraphics = null;
private Bitmap bitmap = null;
private Cursor cursor = null;
private IntPtr intPtr = IntPtr.Zero;
private Pen cursorPen = new Pen(Color.Black);

// Replace the default cursor when begin to move or drag this object 
private Cursor OutlineCursor() {
  // Clean up
  if(cursor != null) cursorGraphics.Dispose();  
  if(cursorGraphics != null) cursorGraphics.Dispose();
  if(bitmap != null) bitmap.Dispose();
  if(intPtr != IntPtr.Zero) DestroyIcon(intPtr);
  // Create a new cursor
  bitmap = new Bitmap(this.Width * 2, this.Height * 2);
  if(cursorGraphics != null) cursorGraphics.Dispose();
  cursorGraphics = Graphics.FromImage(bitmap);
  cursorGraphics.DrawRectangle(cursorPen, this.Width - startPoint.X, this.Height - startPoint.Y, this.Width - 1, this.Height - 1);
  intPtr = bitmap.GetHicon();
  cursor = new Cursor(intPtr);
  return cursor;
}

// Handle mouse-move; If we are out of parent container then preform global drag
private void userControl_MouseMove(object sender, MouseEventArgs mouseEventArgs) {
  // Get the current mouse coordinates as screen coordinates
  Point point = this.PointToScreen(new Point(mouseEventArgs.X, mouseEventArgs.Y));
  // Have we left the parent container?
  if(IsCursorOutside(point) == true) {
    // Unregister this event
    (sender as Control).MouseMove -= new MouseEventHandler(userControl_MouseMove);
    // Clean up
    if(cursorGraphics != null) {
      cursorGraphics.Dispose();
      cursorGraphics = null;
      Parent.Invalidate();
    }
    // Do start the drag-drop action
    this.DoDragDrop(this, DragDropEffects.Move);
  } else {
    // Draw the outline of this object on the parent
    if(cursorGraphics == null) cursorGraphics = Parent.CreateGraphics();
    cursorGraphics.Clear(Parent.BackColor);
    Point cursorPoint = Parent.PointToClient(this.PointToScreen(new Point(mouseEventArgs.X - startPoint.X, mouseEventArgs.Y - startPoint.Y))); 
    cursorGraphics.DrawRectangle(cursorPen, cursorPoint.X, cursorPoint.Y, this.Width - 1, this.Height - 1);
  }
}

int[][] GetData(Rectangle rect, Bitmap b)
{
	int[][] ret = new int[4][];

	int i;
	if (!(new Rectangle(new Point(0, 0), new Size(b.Size.Width-1, b.Size.Height-1)).Contains(rect))
		|| rect.Height < 0 || rect.Width < 0)
		return null;
	ret[0] = new int[rect.Width];
	ret[1] = new int[rect.Height];
	ret[2] = new int[rect.Width];
	ret[3] = new int[rect.Height];
	// NW to NE edge
	for (i = 0; i < rect.Width; i++)
		ret[0][i] = b.GetPixel(rect.X + i, rect.Y).ToArgb();
	// NE to SE
	for (i = 0; i < rect.Height; i++)
		ret[1][i] = b.GetPixel(rect.X + rect.Width, rect.Y + i).ToArgb();
	// SE to SW
	for (i = 0; i < rect.Width; i++)
		ret[2][i] = b.GetPixel(rect.X + rect.Width - i, rect.Y + rect.Height).ToArgb();
	// SW to NW
	for (i = 0; i < rect.Height; i++)
		ret[3][i] = b.GetPixel(rect.X, rect.Y + rect.Height - i).ToArgb();
	return ret;
}

void DrawRectangle(int[][] data, Point p, Bitmap b)
{
	if (data == null) return;
	int width = GetWidth(data);
	int height = GetHeight(data);
	int i;

	// NW to NE
	for (i = 0; i < width; i++)
		b.SetPixel(p.X + i, p.Y, Color.FromArgb(data[0][i]));
	// NE to SE
	for (i = 0; i < height; i++)
		b.SetPixel(p.X + width, p.Y + i, Color.FromArgb(data[1][i]));
	// SE to SW
	for (i = 0; i < width; i++)
		b.SetPixel(p.X + width - i, p.Y + height, Color.FromArgb(data[2][i]));
	// SW to NW
	for (i = 0; i < height; i++)
		b.SetPixel(p.X, p.Y + height - i, Color.FromArgb(data[3][i]));
}

public static void DrawDragOutline(Region region)
{
	if (region == null)
		return;

	// Get hold of the DC for the desktop
	IntPtr hDC = User32.GetDC(IntPtr.Zero);

	// Define the area we are allowed to draw into
	IntPtr hRegion = region.GetHrgn(Graphics.FromHdc(hDC));
	Gdi32.SelectClipRgn(hDC, hRegion);

	Win32.RECT rectBox = new Win32.RECT();
		 
	// Get the smallest rectangle that encloses region
	Gdi32.GetClipBox(hDC, ref rectBox);

	IntPtr brushHandler = GetHalfToneBrush();

	// Select brush into the device context
	IntPtr oldHandle = Gdi32.SelectObject(hDC, brushHandler);

	// Blit to screen using provided pattern brush and invert with existing screen contents
	Gdi32.PatBlt(hDC, 
		rectBox.left, 
		rectBox.top, 
		rectBox.right - rectBox.left, 
		rectBox.bottom - rectBox.top, 
		(uint)Win32.RasterOperations.PATINVERT);

	// Put old handle back again
	Gdi32.SelectObject(hDC, oldHandle);

	// Reset the clipping region
	Gdi32.SelectClipRgn(hDC, IntPtr.Zero);

	Gdi32.DeleteObject(hRegion);

	// Must remember to release the HDC resource!
	User32.ReleaseDC(IntPtr.Zero, hDC);
}

   internal class Gdi32
    {
        [DllImport("gdi32.dll", CharSet=CharSet.Auto)]
        public static extern int CombineRgn(IntPtr dest, IntPtr src1, IntPtr src2, int flags);

        [DllImport("gdi32.dll", CharSet=CharSet.Auto)]
        public static extern IntPtr CreateRectRgnIndirect(ref Win32.RECT rect); 

		[DllImport("gdi32.dll", CharSet=CharSet.Auto)]
		public static extern bool FillRgn(IntPtr hDC, IntPtr hrgn, IntPtr hBrush); 
		
		[DllImport("gdi32.dll", CharSet=CharSet.Auto)]
        public static extern int GetClipBox(IntPtr hDC, ref Win32.RECT rectBox); 

        [DllImport("gdi32.dll", CharSet=CharSet.Auto)]
        public static extern int SelectClipRgn(IntPtr hDC, IntPtr hRgn); 

        [DllImport("gdi32.dll", CharSet=CharSet.Auto)]
        public static extern IntPtr CreateBrushIndirect(ref LOGBRUSH brush); 

        [DllImport("gdi32.dll", CharSet=CharSet.Auto)]
        public static extern bool PatBlt(IntPtr hDC, int x, int y, int width, int height, uint flags); 

        [DllImport("gdi32.dll", CharSet=CharSet.Auto)]
        public static extern IntPtr DeleteObject(IntPtr hObject);

        [DllImport("gdi32.dll", CharSet=CharSet.Auto)]
        public static extern bool DeleteDC(IntPtr hDC);

        [DllImport("gdi32.dll", CharSet=CharSet.Auto)]
        public static extern IntPtr SelectObject(IntPtr hDC, IntPtr hObject);

        [DllImport("gdi32.dll", CharSet=CharSet.Auto)]
        public static extern IntPtr CreateCompatibleDC(IntPtr hDC);
    }