← Back to branch summary

~nunit-core/nunitv2/2.5

« back to all changes in this revision

Viewing changes to src/GuiException/UiException/MouseWatcher.cs

  • Committer: charliepoole
  • Date: 2008-12-11 03:54:36 UTC
  • Revision ID: vcs-imports@canonical.com-20081211035436-thnyyjdctgmlxvot
Exception Browser - Initial Checkin

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/GuiException/UiException/MouseWatcher.cs
 
1
// ----------------------------------------------------------------
 
2
// ExceptionBrowser
 
3
// Version 1.0.0
 
4
// Copyright 2008, Irénée HOTTIER,
 
5
// 
 
6
// This is free software licensed under the NUnit license, You may
 
7
// obtain a copy of the license at http://nunit.org/?p=license&r=2.4
 
8
// ----------------------------------------------------------------
 
9
 
 
10
using System;
 
11
using System.Collections.Generic;
 
12
using System.Text;
 
13
using System.Windows.Forms;
 
14
using System.Diagnostics;
 
15
 
 
16
namespace NUnit.UiException
 
17
{
 
18
    /// <summary>
 
19
    /// Watch events coming from the mouse over a given control hierarchy and
 
20
    /// proprage up events such as: MouseLeaved or MouseClicked to observers.
 
21
    ///     When a MouseLeave event is fired, the class waits a certain amount of time
 
22
    /// to check whether or not a mouseEnter event is coming. If nothing happens
 
23
    /// after this time, the class delivers a mouseLeaved event to registered observers.
 
24
    ///     Unlike MouseLeave, the MouseClicked event is fired when it occurs on
 
25
    /// one of the underlying controls.
 
26
    /// </summary>
 
27
    public class MouseWatcher
 
28
    {
 
29
        /// <summary>
 
30
        /// Default setting that indicate the amount of time to wait (in milliseconds)
 
31
        /// after a mouseLeave event occured.
 
32
        /// </summary>
 
33
        public const int DEFAULT_TIMER_INTERVAL = 500;
 
34
 
 
35
        /// <summary>
 
36
        /// Fired when MouseWatcher has detected that the mouse completely
 
37
        /// get out of the watched control collection.
 
38
        /// </summary>
 
39
        public event EventHandler MouseLeaved;
 
40
 
 
41
        /// <summary>
 
42
        /// Fired when MouseWatcher has detected a click on one of underlying
 
43
        /// control hierarchy.
 
44
        /// </summary>
 
45
        public event EventHandler MouseClicked;
 
46
 
 
47
        /// <summary>
 
48
        /// The list of controls to be watched.
 
49
        /// </summary>
 
50
        private List<Control> _controls;
 
51
 
 
52
        /// <summary>
 
53
        /// The current active control.
 
54
        /// </summary>
 
55
        private Control _active;
 
56
 
 
57
        /// <summary>
 
58
        /// The timer that waits amount of time explained above.
 
59
        /// </summary>
 
60
        private Timer _timer;
 
61
 
 
62
        /// <summary>
 
63
        /// Builds a new instance of MouseWatcher.
 
64
        /// </summary>
 
65
        public MouseWatcher()
 
66
        {
 
67
            _controls = new List<Control>();
 
68
            _timer = new Timer();
 
69
            _timer.Tick += new EventHandler(_timer_Tick);
 
70
            _timer.Interval = DEFAULT_TIMER_INTERVAL;
 
71
 
 
72
            return;
 
73
        }       
 
74
 
 
75
        /// <summary>
 
76
        /// Registers this control in the collection of controls for which 
 
77
        /// mouse interactions must be watched.
 
78
        /// </summary>
 
79
        /// <param name="control">Appends this control to the list of control for which
 
80
        /// mouse interactions must be watched.</param>
 
81
        public void Register(Control control)
 
82
        {
 
83
            TraceExceptionHelper.CheckNotNull(control, "control");
 
84
            _controls.Add(control);
 
85
 
 
86
            control.MouseEnter += new EventHandler(control_MouseEnter);
 
87
            control.MouseLeave += new EventHandler(control_MouseLeave);
 
88
            control.MouseClick += new MouseEventHandler(control_MouseClick);
 
89
 
 
90
            foreach (Control child in control.Controls)
 
91
                Register(child);
 
92
 
 
93
            return;
 
94
        }
 
95
        
 
96
        /// <summary>
 
97
        /// Gets the current active control.
 
98
        /// </summary>
 
99
        public Control Active
 
100
        {
 
101
            get { return (_active); }
 
102
        }
 
103
 
 
104
        /// <summary>
 
105
        /// Gets the count of controls in the list.
 
106
        /// </summary>
 
107
        public int Count
 
108
        {
 
109
            get { return (_controls.Count); }
 
110
        }
 
111
 
 
112
        /// <summary>
 
113
        /// Gives access to the timer.
 
114
        /// </summary>
 
115
        protected Timer Timer
 
116
        {
 
117
            get { return (_timer); }
 
118
        }
 
119
 
 
120
        /// <summary>
 
121
        /// Handler called when a tick occurs.
 
122
        /// </summary>
 
123
        protected void HandleTimerTick()
 
124
        {
 
125
            //Trace.WriteLine("timer: active=" + _active);
 
126
 
 
127
            if (_active != null)
 
128
            {
 
129
                _timer.Enabled = false;
 
130
                return;
 
131
            }
 
132
 
 
133
            //Trace.WriteLine("====> LEAVE");
 
134
 
 
135
            _timer.Enabled = false;
 
136
 
 
137
            if (MouseLeaved != null)
 
138
                MouseLeaved(this, new EventArgs());
 
139
 
 
140
            return;
 
141
        }
 
142
 
 
143
        /// <summary>
 
144
        /// Timer event handler.
 
145
        /// </summary>
 
146
        void _timer_Tick(object sender, EventArgs e)
 
147
        {
 
148
            HandleTimerTick();
 
149
        }
 
150
 
 
151
        /// <summary>
 
152
        /// Handler called when mouse cursor leaved a control.
 
153
        /// </summary>
 
154
        void control_MouseLeave(object sender, EventArgs e)
 
155
        {
 
156
            // Trace.WriteLine(sender + " said: mouse leave");
 
157
 
 
158
            if (_active != sender)
 
159
                return;
 
160
 
 
161
            _active = null;
 
162
            _timer.Enabled = true;
 
163
 
 
164
            return;
 
165
        }
 
166
 
 
167
        /// <summary>
 
168
        /// Handler called when a click has occured on
 
169
        /// control hierarchy.
 
170
        /// </summary>
 
171
        void control_MouseClick(object sender, MouseEventArgs e)
 
172
        {
 
173
            if (MouseClicked != null)
 
174
                MouseClicked(this, e);
 
175
 
 
176
            return;
 
177
        }
 
178
 
 
179
        /// <summary>
 
180
        /// Handler called when mouse cursor entered a control.
 
181
        /// </summary>
 
182
        void control_MouseEnter(object sender, EventArgs e)
 
183
        {
 
184
            //Trace.WriteLine(sender + " said mouse enter");
 
185
            _active = (Control)sender;
 
186
        }        
 
187
    }
 
188
}