C#

using System;
using System.Drawing;
using System.Drawing.Drawing2D;

namespace some_namespace
{
    class Transformation
    {
        // world: the real world your bitmap represents
        // bitmap: your (unscaled) bitmap
        // screen: the portion of the screen that you display the image (a picture box maybe)

        Matrix matrix_world;       // bitmap to world
        Matrix inv_matrix_world;   // world to bitmap
        Matrix matrix_bitmap;      // screen to bitmap
        Matrix inv_matrix_bitmap;  // bitmap to screen

        Size bitmap_size;
        Size screen_size;


        public Transformation(PointF worldOrigin, SizeF worldSize, 
            Size bitmapSize, Size screenSize)
        {
            matrix_world = new Matrix();
            matrix_bitmap = new Matrix();
            bitmap_size = bitmapSize;
            screen_size = screenSize;

            // if you want the native y-points up coord system for the world, uncomment '-' and
            // '+ worldSize.Height' below
            matrix_world.Scale(worldSize.Width / (float)bitmap_size.Width, 
               /* - */ worldSize.Height / (float)bitmap_size.Height);                 
            matrix_world.Translate(worldOrigin.X, 
                worldOrigin.Y /* + worldSize.Height */, MatrixOrder.Append);
            inv_matrix_world = matrix_world.Clone();
            inv_matrix_world.Invert();
            Reset();
        }
 
        // Reset transformation to the 'screen portion displays entire bitmap'
        public void Reset()
        {
            matrix_bitmap.Reset();
            matrix_bitmap.Scale((float)bitmap_size.Width / (float)screen_size.Width, 
                (float)bitmap_size.Height / (float)screen_size.Height);
            inv_matrix_bitmap = matrix_bitmap.Clone();
            inv_matrix_bitmap.Invert();
        }

        // transform to 'screen portion displays the rectangular portion of the bitmap 
        // defined by the displayOrigin point and the displaySize'
        public void Transform(PointF displayOrigin, SizeF displaySize)
        {
            matrix_bitmap.Reset();
            matrix_bitmap.Scale(displaySize.Width / (float)screen_size.Width, 
                displaySize.Height / (float)screen_size.Height);
            matrix_bitmap.Translate(displayOrigin.X, displayOrigin.Y, MatrixOrder.Append);
            inv_matrix_bitmap = matrix_bitmap.Clone();
            inv_matrix_bitmap.Invert();
        }


        // pretty obvious what they do
        //
        public void ScreenToBitmap(Point[] points)
        {
            matrix_bitmap.TransformPoints(points);
        }

        public void BitmapToScreen(Point[] points)
        {
            inv_matrix_bitmap.TransformPoints(points);
        }

        public void BitmapToWorld(Point[] points)
        {
            matrix_world.TransformPoints(points);
        }

        public void WorldToBitmap(Point[] points)
        {
            inv_matrix_world.TransformPoints(points);
        }

        public void ScreenToWorld(Point[] points)
        {
            ScreenToBitmap(points);
            BitmapToWorld(points);
        }

        public void WorldToScreen(Point[] points)
        {
            WorldToBitmap(points);
            BitmapToScreen(points);
        }
    }
}

Point[] pts = new Point[]{pointMouseDown,pointMouseUp};
transformation.ScreenToBitmap(pts);
// and drawing
graphics.DrawImage(bitmap,new Rectangle(0,0,1000,1000), pts[0].X,pts[0].Y,pts[1].X-pts[0].X,
pts[1].Y-pts.[0].Y,GraphicUnit.Pixel);
// dont forget to inform transformation object for the zoom
transformation.Transform(pts[0],new Size(pts[1].X-pts[0].X,ts[1].Y-pts.[0].Y);

private void findcontrol(Control.ControlCollection controls) {
   foreach (Control ctrl in controls) {
      WhateverControlYouWant whatEver = ctrl as WhateverControlYouWant;
      if (whatEver != null) {
         // here you can use the whatEver variable
      }
      findcontrol(ctrl.Controls);
   }
}

private void ProcessControls<T>(Control.ControlCollection controls, Action<T> action) {
   foreach (Control ctrl in controls) {
      T t = ctrl as T;
      if (t != null) {
         action(t);
      }
      ProcessControls<T>(ctrl.Controls, action);
   }
}

ProcessControls<Button>(this, delegate(Button b){ b.Enabled = false; });