Как привязать пользовательский класс к стандартным элементам управления на форме

public partial class PictureBoxEx : UserControl
    {
        Image image;
        Bitmap visibleImage;
        Graphics visibleImageGraphics;
        float visibleImageZoom = 1f;
        Point visibleCenter;
        bool needRecalc;
        float rotate = 0f;
        float zoom = 1f;
        InterpolationMode interpolationMode = InterpolationMode.Default;
        MouseState mouseState;
        Point startDragged;
        float startRotate;
        Point startDraggedVisibleCenter;
 
        [DefaultValue(0.1f)]
        public float ZoomDelta { get; set; }
        [DefaultValue(0.2f)]
        public float RotateDelta { get; set; }
        [DefaultValue(true)]
        public bool AllowUserDrag { get; set; }
        [DefaultValue(true)]
        public bool AllowUserRotate { get; set; }
        [DefaultValue(true)]
        public bool AllowUserZoom { get; set; }
 
        public PictureBoxEx()
        {
            //drawing optimization
            SetStyle(ControlStyles.AllPaintingInWmPaint, true);
            SetStyle(ControlStyles.UserPaint, true);
            SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
            SetStyle(ControlStyles.ResizeRedraw, true);
            //default settings
            ZoomDelta = 0.1f;
            RotateDelta = 0.2f;
            AllowUserDrag = true;
            AllowUserZoom = true;
            AllowUserRotate = true;
        }
 
        public Image Image
        {
            get { return image; }
            set
            {
                image = value;
                needRecalc = true;
                if (image != null)
                    visibleCenter = new Point(image.Width / 2, image.Height / 2);
                else
                    visibleCenter = new Point(0, 0);
                Invalidate();
            }
        }
 
        [DefaultValue(0f)]
        public float Rotate
        {
            get
            {
                return rotate;
            }
 
            set
            {
                rotate = value;
                Invalidate();
            }
        }
 
        [DefaultValue(1f)]
        public float Zoom
        {
            get
            {
                return zoom;
            }
 
            set
            {
                if (Math.Abs(value) <= float.Epsilon)
                    throw new Exception("Zoom must be more then 0");
                zoom = value;
                needRecalc = true;
                Invalidate();
            }
        }
 
        public Point VisibleCenter
        {
            get
            {
                return visibleCenter;
            }
 
            set
            {
                visibleCenter = value;
                needRecalc = true;
                Invalidate();
            }
        }
 
        [DefaultValue(typeof(InterpolationMode), "Default")]
        public InterpolationMode InterpolationMode
        {
            get { return interpolationMode; }
            set
            {
                if (value == System.Drawing.Drawing2D.InterpolationMode.Invalid)
                    return;
                interpolationMode = value;
                needRecalc = true;
                Invalidate();
            }
        }
 
        protected override void OnMouseWheel(MouseEventArgs e)
        {
            base.OnMouseWheel(e);
 
            if (!AllowUserZoom)
                return;
 
            if (e.Delta > 0)
                IncreazeZoom();
 
            if (e.Delta < 0)
                DecreaseZoom();
        }
 
        protected override void OnMouseDown(MouseEventArgs e)
        {
            base.OnMouseDown(e);
 
            if (AllowUserDrag)
                if (e.Button == System.Windows.Forms.MouseButtons.Left)
                {
                    Cursor = Cursors.SizeAll;
                    mouseState = MouseState.Drag;
                }
 
            if (AllowUserRotate)
                if (e.Button == System.Windows.Forms.MouseButtons.Right)
                {
                    Cursor = Cursors.SizeNS;
                    mouseState = MouseState.Rotate;
                }
 
            startDragged = e.Location;
            startRotate = Rotate;
            startDraggedVisibleCenter = VisibleCenter;
        }
 
        protected override void OnMouseUp(MouseEventArgs e)
        {
            base.OnMouseUp(e);
            Cursor = Cursors.Default;
            mouseState = MouseState.None;
        }
 
        protected override void OnMouseMove(MouseEventArgs e)
        {
            base.OnMouseMove(e);
            if (mouseState == MouseState.Drag)
            {
                Point d = new Point(e.Location.X - startDragged.X, e.Location.Y - startDragged.Y);
                double a = -Math.PI * rotate / 180;
                double dx = d.X * Math.Cos(a) - d.Y * Math.Sin(a);
                double dy = d.X * Math.Sin(a) + d.Y * Math.Cos(a);
                VisibleCenter = new Point((int)(startDraggedVisibleCenter.X - dx / zoom), (int)(startDraggedVisibleCenter.Y - dy / zoom));
            }
 
            if (mouseState == MouseState.Rotate)
            {
                Point d = new Point(e.Location.X - startDragged.X, e.Location.Y - startDragged.Y);
                Rotate = startRotate + d.Y * RotateDelta;
            }
        }
 
        private void DecreaseZoom()
        {
            Zoom = (float)Math.Exp(Math.Log(zoom) - ZoomDelta);
        }
 
        private void IncreazeZoom()
        {
            Zoom = (float)Math.Exp(Math.Log(zoom) + ZoomDelta);
        }
 
        protected override void OnPaint(PaintEventArgs e)
        {
            if (needRecalc)
                Recalc();
            if (visibleImage == null)
                return;
            e.Graphics.TranslateTransform(ClientSize.Width / 2f, ClientSize.Height / 2f);
            e.Graphics.RotateTransform(rotate);
            e.Graphics.ScaleTransform(visibleImageZoom, visibleImageZoom);
            e.Graphics.DrawImageUnscaled(visibleImage, -visibleImage.Width / 2, -visibleImage.Height / 2);
        }
 
        protected override void OnClientSizeChanged(EventArgs e)
        {
            int w = (int)Math.Round(ClientSize.Width * Math.Sqrt(2));
            int h = (int)Math.Round(ClientSize.Height * Math.Sqrt(2));
            int s = Math.Max(h, w);
            if (s == 0)
                return;
            visibleImage = new Bitmap(s, s);
            visibleImageGraphics = Graphics.FromImage(visibleImage);
            needRecalc = true;
            Invalidate();
        }
 
        private void Recalc()
        {
            if (!needRecalc)
                return;
            needRecalc = false;
            if (visibleImageGraphics == null)
                OnClientSizeChanged(null);
            if (image == null)
                return;
            visibleImageZoom = 1f;
            visibleImageGraphics.ResetTransform();
            visibleImageGraphics.Clear(BackColor);
            visibleImageGraphics.TranslateTransform(visibleImage.Width / 2, visibleImage.Height / 2);
            visibleImageGraphics.ScaleTransform(zoom, zoom);
            visibleImageGraphics.InterpolationMode = InterpolationMode;
            visibleImageGraphics.DrawImageUnscaled(image, -(int)(visibleCenter.X), -(int)(visibleCenter.Y));
        }
 
        enum MouseState
        {
            None, Drag, Rotate
        }
    }