← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/qwt/oneiric-proposed

« back to all changes in this revision

Viewing changes to qwt-5.1.1/src/qwt_picker_machine.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Fathi Boudra
  • Date: 2009-04-12 23:25:58 UTC
  • mfrom: (1.1.4 upstream) (2.1.2 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090412232558-3bl06x785yr8xm8u
Tags: 5.1.2-1
* New upstream release.
* Bump compat/debhelper to 7.
* Bump Standards-Version to 3.8.1. No changes needed.
* Invert Maintainers and Uploaders field.
* Fix lintian warnings:
  - dh_clean _k deprecated.
  - missing dependency on libc.

Show diffs side-by-side

added added

removed removed

Lines of Context:
qwt-5.1.1/src/qwt_picker_machine.cpp
1
 
/* -*- mode: C++ ; c-file-style: "stroustrup" -*- *****************************
2
 
 * Qwt Widget Library
3
 
 * Copyright (C) 1997   Josef Wilgen
4
 
 * Copyright (C) 2002   Uwe Rathmann
5
 
 *
6
 
 * This library is free software; you can redistribute it and/or
7
 
 * modify it under the terms of the Qwt License, Version 1.0
8
 
 *****************************************************************************/
9
 
 
10
 
#include <qevent.h>
11
 
#include "qwt_event_pattern.h"
12
 
#include "qwt_picker_machine.h"
13
 
 
14
 
//! Constructor
15
 
QwtPickerMachine::QwtPickerMachine():
16
 
    d_state(0)
17
 
{
18
 
}
19
 
 
20
 
//! Destructor
21
 
QwtPickerMachine::~QwtPickerMachine()
22
 
{
23
 
}
24
 
 
25
 
//! Return the current state
26
 
int QwtPickerMachine::state() const
27
 
{
28
 
    return d_state;
29
 
}
30
 
 
31
 
//! Change the current state
32
 
void QwtPickerMachine::setState(int state)
33
 
{
34
 
    d_state = state;
35
 
}
36
 
 
37
 
//! Set the current state to 0.
38
 
void QwtPickerMachine::reset() 
39
 
{
40
 
    setState(0);
41
 
}
42
 
 
43
 
//! Transition
44
 
QwtPickerMachine::CommandList QwtPickerClickPointMachine::transition(
45
 
    const QwtEventPattern &eventPattern, const QEvent *e)
46
 
{   
47
 
    QwtPickerMachine::CommandList cmdList;
48
 
 
49
 
    switch(e->type())
50
 
    {
51
 
        case QEvent::MouseButtonPress:
52
 
        {
53
 
            if ( eventPattern.mouseMatch(
54
 
                QwtEventPattern::MouseSelect1, (const QMouseEvent *)e) )
55
 
            {
56
 
                cmdList += Begin;
57
 
                cmdList += Append;
58
 
                cmdList += End;
59
 
            }
60
 
            break;
61
 
        }
62
 
        case QEvent::KeyPress:
63
 
        {   
64
 
            if ( eventPattern.keyMatch(
65
 
                QwtEventPattern::KeySelect1, (const QKeyEvent *)e) )
66
 
            {
67
 
                cmdList += Begin;
68
 
                cmdList += Append;
69
 
                cmdList += End;
70
 
            }   
71
 
            break;
72
 
        }
73
 
        default:
74
 
            break;
75
 
    }
76
 
 
77
 
    return cmdList;
78
 
}
79
 
 
80
 
//! Transition
81
 
QwtPickerMachine::CommandList QwtPickerDragPointMachine::transition(
82
 
    const QwtEventPattern &eventPattern, const QEvent *e)
83
 
{   
84
 
    QwtPickerMachine::CommandList cmdList;
85
 
 
86
 
    switch(e->type())
87
 
    {
88
 
        case QEvent::MouseButtonPress:
89
 
        {
90
 
            if ( eventPattern.mouseMatch(
91
 
                QwtEventPattern::MouseSelect1, (const QMouseEvent *)e) )
92
 
            {
93
 
                if ( state() == 0 )
94
 
                {
95
 
                    cmdList += Begin;
96
 
                    cmdList += Append;
97
 
                    setState(1);
98
 
                }
99
 
            }
100
 
            break;
101
 
        }
102
 
        case QEvent::MouseMove:
103
 
        case QEvent::Wheel:
104
 
        {
105
 
            if ( state() != 0 )
106
 
                cmdList += Move;
107
 
            break;
108
 
        }
109
 
        case QEvent::MouseButtonRelease:
110
 
        {
111
 
            if ( state() != 0 )
112
 
            {
113
 
                cmdList += End;
114
 
                setState(0);
115
 
            }
116
 
            break;
117
 
        }
118
 
        case QEvent::KeyPress:
119
 
        {
120
 
            if ( eventPattern.keyMatch(
121
 
                QwtEventPattern::KeySelect1, (const QKeyEvent *)e) )
122
 
            {
123
 
                if ( state() == 0 )
124
 
                {
125
 
                    cmdList += Begin;
126
 
                    cmdList += Append;
127
 
                    setState(1);
128
 
                }
129
 
                else
130
 
                {
131
 
                    cmdList += End;
132
 
                    setState(0);
133
 
                }
134
 
            }
135
 
            break;
136
 
        }
137
 
        default:
138
 
            break;
139
 
    }
140
 
 
141
 
    return cmdList;
142
 
}
143
 
 
144
 
//! Transition
145
 
QwtPickerMachine::CommandList QwtPickerClickRectMachine::transition(
146
 
    const QwtEventPattern &eventPattern, const QEvent *e)
147
 
{   
148
 
    QwtPickerMachine::CommandList cmdList;
149
 
 
150
 
    switch(e->type())
151
 
    {
152
 
        case QEvent::MouseButtonPress:
153
 
        {
154
 
            if ( eventPattern.mouseMatch(
155
 
                QwtEventPattern::MouseSelect1, (const QMouseEvent *)e) )
156
 
            {
157
 
                switch(state())
158
 
                {
159
 
                    case 0:
160
 
                    {   
161
 
                        cmdList += Begin;
162
 
                        cmdList += Append;
163
 
                        setState(1);
164
 
                        break;
165
 
                    }
166
 
                    case 1:
167
 
                    {
168
 
                        // Uh, strange we missed the MouseButtonRelease
169
 
                        break; 
170
 
                    }
171
 
                    default:
172
 
                    {
173
 
                        cmdList += End;
174
 
                        setState(0);
175
 
                    }
176
 
                }
177
 
            }
178
 
        }
179
 
        case QEvent::MouseMove:
180
 
        case QEvent::Wheel:
181
 
        {
182
 
            if ( state() != 0 )
183
 
                cmdList += Move;
184
 
            break;
185
 
        }
186
 
        case QEvent::MouseButtonRelease:
187
 
        {
188
 
            if ( eventPattern.mouseMatch(
189
 
                QwtEventPattern::MouseSelect1, (const QMouseEvent *)e) )
190
 
            {
191
 
                if ( state() == 1 )
192
 
                {
193
 
                    cmdList += Append;
194
 
                    setState(2);
195
 
                }
196
 
            }
197
 
            break;
198
 
        }
199
 
        case QEvent::KeyPress:
200
 
        {   
201
 
            if ( eventPattern.keyMatch(
202
 
                QwtEventPattern::KeySelect1, (const QKeyEvent *)e) )
203
 
            {
204
 
                if ( state() == 0 )
205
 
                {
206
 
                    cmdList += Begin;
207
 
                    cmdList += Append;
208
 
                    setState(1);
209
 
                }
210
 
                else
211
 
                {
212
 
                    if ( state() == 1 )
213
 
                    {
214
 
                        cmdList += Append;
215
 
                        setState(2);
216
 
                    }
217
 
                    else if ( state() == 2 )
218
 
                    {
219
 
                        cmdList += End;
220
 
                        setState(0);
221
 
                    }
222
 
                }
223
 
            }   
224
 
            break;
225
 
        }
226
 
        default:
227
 
            break;
228
 
    }
229
 
 
230
 
    return cmdList;
231
 
}
232
 
 
233
 
//! Transition
234
 
QwtPickerMachine::CommandList QwtPickerDragRectMachine::transition(
235
 
    const QwtEventPattern &eventPattern, const QEvent *e)
236
 
{   
237
 
    QwtPickerMachine::CommandList cmdList;
238
 
 
239
 
    switch(e->type())
240
 
    {
241
 
        case QEvent::MouseButtonPress:
242
 
        {
243
 
            if ( eventPattern.mouseMatch(
244
 
                QwtEventPattern::MouseSelect1, (const QMouseEvent *)e) )
245
 
            {
246
 
                if ( state() == 0 )
247
 
                {
248
 
                    cmdList += Begin;
249
 
                    cmdList += Append;
250
 
                    cmdList += Append;
251
 
                    setState(2);
252
 
                }
253
 
            }
254
 
            break;
255
 
        }
256
 
        case QEvent::MouseMove:
257
 
        case QEvent::Wheel:
258
 
        {
259
 
            if ( state() != 0 )
260
 
                cmdList += Move;
261
 
            break;
262
 
        }
263
 
        case QEvent::MouseButtonRelease:
264
 
        {
265
 
            if ( state() == 2 )
266
 
            {
267
 
                cmdList += End;
268
 
                setState(0);
269
 
            }
270
 
            break;
271
 
        }
272
 
        case QEvent::KeyPress:
273
 
        {
274
 
            if ( eventPattern.keyMatch(
275
 
                QwtEventPattern::KeySelect1, (const QKeyEvent *)e) )
276
 
            {
277
 
                if ( state() == 0 )
278
 
                {
279
 
                    cmdList += Begin;
280
 
                    cmdList += Append;
281
 
                    cmdList += Append;
282
 
                    setState(2);
283
 
                }
284
 
                else
285
 
                {
286
 
                    cmdList += End;
287
 
                    setState(0);
288
 
                }
289
 
            }
290
 
            break;
291
 
        }
292
 
        default:
293
 
            break;
294
 
    }
295
 
 
296
 
    return cmdList;
297
 
}
298
 
 
299
 
//! Transition
300
 
QwtPickerMachine::CommandList QwtPickerPolygonMachine::transition(
301
 
    const QwtEventPattern &eventPattern, const QEvent *e)
302
 
{
303
 
    QwtPickerMachine::CommandList cmdList;
304
 
 
305
 
    switch(e->type())
306
 
    {
307
 
        case QEvent::MouseButtonPress:
308
 
        {
309
 
            if ( eventPattern.mouseMatch(
310
 
                QwtEventPattern::MouseSelect1, (const QMouseEvent *)e) )
311
 
            {
312
 
                if (state() == 0)
313
 
                {
314
 
                    cmdList += Begin;
315
 
                    cmdList += Append;
316
 
                    cmdList += Append;
317
 
                    setState(1);
318
 
                }
319
 
                else
320
 
                {
321
 
                    cmdList += End;
322
 
                    setState(0);
323
 
                }
324
 
            }
325
 
            if ( eventPattern.mouseMatch(
326
 
                QwtEventPattern::MouseSelect2, (const QMouseEvent *)e) )
327
 
            {
328
 
                if (state() == 1)
329
 
                    cmdList += Append;
330
 
            }
331
 
            break;
332
 
        }
333
 
        case QEvent::MouseMove:
334
 
        case QEvent::Wheel:
335
 
        {
336
 
            if ( state() != 0 )
337
 
                cmdList += Move;
338
 
            break;
339
 
        }
340
 
        case QEvent::KeyPress:
341
 
        {
342
 
            if ( eventPattern.keyMatch(
343
 
                QwtEventPattern::KeySelect1, (const QKeyEvent *)e) )
344
 
            {
345
 
                if ( state() == 0 )
346
 
                {
347
 
                    cmdList += Begin;
348
 
                    cmdList += Append;
349
 
                    cmdList += Append;
350
 
                    setState(1);
351
 
                }
352
 
                else
353
 
                {
354
 
                    cmdList += End;
355
 
                    setState(0);
356
 
                }
357
 
            }
358
 
            else if ( eventPattern.keyMatch(
359
 
                QwtEventPattern::KeySelect2, (const QKeyEvent *)e) )
360
 
            {
361
 
                if ( state() == 1 )
362
 
                    cmdList += Append;
363
 
            }
364
 
            break;
365
 
        }
366
 
        default:
367
 
            break;
368
 
    }
369
 
 
370
 
    return cmdList;
371
 
}