← Back to branch summary

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

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Fathi Boudra
  • Date: 2007-10-05 15:20:41 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20071005152041-qmybqh4fj9jejyo2
Tags: 5.0.2-2
http://bugs.debian.org/437877
http://bugs.debian.org/443110
* Handle nostrip build option. (Closes: #437877)
* Build libqwt5-doc package in binary-indep target. (Closes: #443110)

Show diffs side-by-side

added added

removed removed

Lines of Context:
qwt-5.0.2/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
}