1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:

    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 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
    }