SensitivOpacityExtension Maus + Form + Transparenz

Beschreibung:

Ich hab hier mal ne kleine Klasse geschrieben die die Entfernung zwischen Maus und Formrand misst und diese Entfernung in eine Transparenz umsetzt. Natürlich ist es möglich die maximale/minimale Transparenz festzulegen.

Verlässt der User das Form mit der Maus wird die Transparenz innerhalb des OpacityTouchRadius prozentual weniger. Es schwindet. Kommt der User dem Form wieder näher wird es wieder sichtbarer. Dabei werden natürlich die grenzen OpacityMin und OpacityMax berüclsichtigt.

Feedback ist immer gerne gesehen.

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Text;

    public class SensitivOpacityExtension : IDisposable
    {
        #region "-- public Propertys --"
        private int opacityTouchRadius = 300;
        /// <summary>
        /// Das ist der "Radius" in dem die Tranzparenzänderungen wirksam sind.
        /// The "radius" where the opacity changes take effect.
        /// </summary>
        public int OpacityTouchRadius
        {
            get { return opacityTouchRadius; }
            set { opacityTouchRadius = value; recalculate(); }
        }

        private double opacityMin = 0.25;
        /// <summary>
        /// Das Minimum der zu erreichenden Tranzparenz.
        /// The minimum of opacity to reach.
        /// </summary>
        public double OpacityMin
        {
            get { return opacityMin; }
            set { opacityMin = value; recalculate(); }
        }

        private double opacityMax = 1;
        /// <summary>
        /// Das Maximum der zu erreichenden Tranzparenz.
        /// The maximum of opacity to reach.
        /// </summary>
        public double OpacityMax
        {
            get { return opacityMax; }
            set { opacityMax = value; recalculate(); }
        }

        private bool active = false;
        /// <summary>
        /// Schaltet die funktionen dieser Klasse an oder ab.
        /// Switch the changes on or off.
        /// </summary>
        public bool Active
        {
            get { return active; }
            set { active = value; }
        }

        private Form form;
        /// <summary>
        /// Gibt das Formular an welches die Änderungen der Tranzparenz empfängt.
        /// The Form who takes effect of the opacity changes.
        /// </summary>
        public Form Form
        {
            get { return form; }
            set { form = value; }
        }
        #endregion

        #region "-- private Members --"
        /// <summary>
        /// Wert zum berechnen der tatsächlichen Tranzparenz
        /// Value to calculate the transparens.
        /// </summary>
        private double opacityStep = -1;
        /// <summary>
        /// Statischer Zeitgeber dieser Klasse. Jede Instanz dieser Klasse nutzt diesen Zeitgeber.
        /// Static Timeprovider. Every instance of this class will use it.
        /// </summary>
        private static Timer tMouseCapture = null;
        #endregion

        #region "-- public Functions & Constructor --"
        public SensitivOpacityExtension(Form form)
        {
            this.form = form;
            recalculate();

            if (tMouseCapture == null)
            {
                tMouseCapture = new Timer();
                tMouseCapture.Interval = 10;
                tMouseCapture.Enabled = true;
            }

            tMouseCapture.Tick += new EventHandler(tMouseCapture_Tick);
        }

        /// <summary>
        /// Selbsterklärend?
        /// It's pretty selfexplanatory.
        /// </summary>
        public void Start()
        {
            active = true;
        }

        /// <summary>
        /// Selbsterklärend?
        /// It's pretty selfexplanatory.
        /// </summary>
        public void Stop()
        {
            active = false;
            form.Opacity = opacityMax;
        }
        #endregion

        #region "-- private Functions --"
        private void tMouseCapture_Tick(object sender, EventArgs e)
        {
            if (!active) return;
            if (form == null) return;

            Point mpos = Cursor.Position;

            if (form.Bounds.Contains(mpos))
            {
                form.Opacity = opacityMax;
            }
            else
            {
                Rectangle fr = form.Bounds;

                double dist = 0;
                int a, b;

                if (fr.Top > mpos.Y && fr.Left > mpos.X) //  TOPLEFT CORNER
                {
                    // distance between 2 points.
                    a = fr.Left - mpos.X;
                    b = fr.Top - mpos.Y;
                    dist = Math.Sqrt(a * a + b * b);
                }
                else if (fr.Top > mpos.Y && fr.Right < mpos.X) // TOPRIGHT CORNER
                {
                    // distance between 2 points.
                    a = fr.Right - mpos.X;
                    b = fr.Top - mpos.Y;
                    dist = Math.Sqrt(a * a + b * b);
                }
                else if (fr.Bottom < mpos.Y && fr.Right < mpos.X) // BOTTOMRIGHT CORNER
                {
                    // distance between 2 points.
                    a = fr.Bottom - mpos.Y;
                    b = fr.Right - mpos.X;
                    dist = Math.Sqrt(a * a + b * b);
                }
                else if (fr.Bottom < mpos.Y && fr.Left > mpos.X) // BOTTOMLEFT CORNER
                {
                    // distance between 2 points.
                    a = fr.Bottom - mpos.Y;
                    b = fr.Left - mpos.X;
                    dist = Math.Sqrt(a * a + b * b);
                }


                else if (fr.Top > mpos.Y) // TOP
                {
                    dist = fr.Top - mpos.Y;
                }
                else if (fr.Right < mpos.X) // RIGHT
                {
                    dist = mpos.X - fr.Right;
                }
                else if (fr.Bottom < mpos.Y) // BOTTOM
                {
                    dist = mpos.Y - fr.Bottom;
                }
                else if (fr.Left > mpos.X) // LEFT
                {
                    dist = fr.Left - mpos.X;
                }


                if (dist > opacityTouchRadius)
                    form.Opacity = opacityMin;
                else
                {
                    form.Opacity = opacityMax - opacityStep * dist;
                }
            }

        }

        private void recalculate()
        {
            double mval = opacityMax - opacityMin;
            opacityStep = (mval / (double)opacityTouchRadius);
        }
        #endregion

        #region IDisposable Member
        public void Dispose()
        {
            if (tMouseCapture != null)
                tMouseCapture.Tick -= tMouseCapture_Tick;
        }
        #endregion
    }

Schlagwörter: Mouse, Transparent, Tranzparenz, Form

schöne komponente. allerdings kann der timer die 10 ms ticks niemals einhalten und gerade so ein pollingmechanismus ist nicht gerade schön. dafür gibt es bessere methoden.

Joa wie recht du da hast, aber wie faul man doch um 3Uhr Nachts sein kann... 😄 werd das gegebenenfalls mal korrigieren.