← Back to branch summary

~ubuntu-branches/debian/sid/v4l-utils/sid

« back to all changes in this revision

Viewing changes to utils/qv4l2-qt3/ctrl-tab.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Gregor Jasny
  • Date: 2010-05-07 20:48:34 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20100507204834-ga01cxhz3fekk47r
Tags: 0.8.0-1
http://bugs.debian.org/576422
* New upstream version
* Switch to 3.0 (quilt) source format
* Re-enable pristine-tar
* Split utils package into command line and the Qt based qv4l2
  (Closes: #576422)
* Update upstream URL

Show diffs side-by-side

added added

removed removed

Lines of Context:
utils/qv4l2-qt3/ctrl-tab.cpp
1
 
 
2
 
#include "qv4l2.h"
3
 
#include "libv4l2util.h"
4
 
 
5
 
#include <qstatusbar.h>
6
 
#include <qlineedit.h>
7
 
#include <qvalidator.h>
8
 
#include <qlayout.h>
9
 
#include <qvbox.h>
10
 
#include <qhbox.h>
11
 
#include <qlabel.h>
12
 
#include <qslider.h>
13
 
#include <qspinbox.h>
14
 
#include <qcombobox.h>
15
 
#include <qcheckbox.h>
16
 
#include <qpushbutton.h>
17
 
#include <qtooltip.h>
18
 
#include <qwhatsthis.h>
19
 
 
20
 
#include <fcntl.h>
21
 
#include <sys/ioctl.h>
22
 
#include <errno.h>
23
 
 
24
 
void ApplicationWindow::addTabs()
25
 
{
26
 
        struct v4l2_queryctrl qctrl;
27
 
        unsigned ctrl_class;
28
 
        unsigned i;
29
 
        int id;
30
 
 
31
 
        memset(&qctrl, 0, sizeof(qctrl));
32
 
        qctrl.id = V4L2_CTRL_FLAG_NEXT_CTRL;
33
 
        while (::ioctl(fd, VIDIOC_QUERYCTRL, &qctrl) == 0) {
34
 
                if ((qctrl.flags & V4L2_CTRL_FLAG_DISABLED) == 0) {
35
 
                        ctrlMap[qctrl.id] = qctrl;
36
 
                        if (qctrl.type != V4L2_CTRL_TYPE_CTRL_CLASS)
37
 
                                classMap[V4L2_CTRL_ID2CLASS(qctrl.id)].push_back(qctrl.id);
38
 
                }
39
 
                qctrl.id |= V4L2_CTRL_FLAG_NEXT_CTRL;
40
 
        }
41
 
        if (qctrl.id == V4L2_CTRL_FLAG_NEXT_CTRL) {
42
 
                strcpy((char *)qctrl.name, "User Controls");
43
 
                qctrl.id = V4L2_CTRL_CLASS_USER | 1;
44
 
                qctrl.type = V4L2_CTRL_TYPE_CTRL_CLASS;
45
 
                ctrlMap[qctrl.id] = qctrl;
46
 
                for (id = V4L2_CID_USER_BASE; id < V4L2_CID_LASTP1; id++) {
47
 
                        qctrl.id = id;
48
 
                        if (::ioctl(fd, VIDIOC_QUERYCTRL, &qctrl))
49
 
                                continue;
50
 
                        if (qctrl.flags & V4L2_CTRL_FLAG_DISABLED)
51
 
                                continue;
52
 
                        ctrlMap[qctrl.id] = qctrl;
53
 
                        classMap[V4L2_CTRL_CLASS_USER].push_back(qctrl.id);
54
 
                }
55
 
                for (qctrl.id = V4L2_CID_PRIVATE_BASE;
56
 
                                ::ioctl(fd, VIDIOC_QUERYCTRL, &qctrl) == 0; qctrl.id++) {
57
 
                        if (qctrl.flags & V4L2_CTRL_FLAG_DISABLED)
58
 
                                continue;
59
 
                        ctrlMap[qctrl.id] = qctrl;
60
 
                        classMap[V4L2_CTRL_CLASS_USER].push_back(qctrl.id);
61
 
                }
62
 
        }
63
 
 
64
 
        for (ClassMap::iterator iter = classMap.begin(); iter != classMap.end(); ++iter) {
65
 
                ctrl_class = V4L2_CTRL_ID2CLASS(iter->second[0]);
66
 
                id = ctrl_class | 1;
67
 
                const struct v4l2_queryctrl &qctrl = ctrlMap[id];
68
 
                QVBox *vbox = new QVBox(tabs);
69
 
                QGrid *grid = new QGrid(4, vbox);
70
 
                grid->setSpacing(3);
71
 
                tabs->addTab(vbox, (char *)qctrl.name);
72
 
                for (i = 0; i < iter->second.size(); i++) {
73
 
                        if (i & 1)
74
 
                                id = iter->second[(1+iter->second.size()) / 2 + i / 2];
75
 
                        else
76
 
                                id = iter->second[i / 2];
77
 
                        addCtrl(grid, ctrlMap[id]);
78
 
                }
79
 
                finishGrid(vbox, grid, ctrl_class, i & 1);
80
 
        }
81
 
}
82
 
 
83
 
void ApplicationWindow::finishGrid(QWidget *vbox, QGrid *grid, unsigned ctrl_class, bool odd)
84
 
{
85
 
        if (odd) {
86
 
                new QWidget(grid);
87
 
                new QWidget(grid);
88
 
        }
89
 
        QWidget *stretch = new QWidget(grid);
90
 
        stretch->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Ignored);
91
 
 
92
 
        QFrame *frame = new QFrame(vbox);
93
 
        frame->setFrameShape(QFrame::HLine);
94
 
        frame->setFrameShadow(QFrame::Sunken);
95
 
        frame->setMargin(3);
96
 
 
97
 
        QHBox *hbox = new QHBox(vbox);
98
 
        hbox->setSpacing(3);
99
 
 
100
 
        QCheckBox *cbox = new QCheckBox("Update on change", hbox);
101
 
        widgetMap[ctrl_class | CTRL_UPDATE_ON_CHANGE] = cbox;
102
 
        connect(cbox, SIGNAL(clicked()), sigMapper, SLOT(map()));
103
 
        sigMapper->setMapping(cbox, ctrl_class | CTRL_UPDATE_ON_CHANGE);
104
 
 
105
 
        stretch = new QWidget(hbox);
106
 
        stretch->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Fixed);
107
 
 
108
 
        QPushButton *defBut = new QPushButton("Set Defaults", hbox);
109
 
        widgetMap[ctrl_class | CTRL_DEFAULTS] = defBut;
110
 
        connect(defBut, SIGNAL(clicked()), sigMapper, SLOT(map()));
111
 
        sigMapper->setMapping(defBut, ctrl_class | CTRL_DEFAULTS);
112
 
 
113
 
        QPushButton *refreshBut = new QPushButton("Refresh", hbox);
114
 
        widgetMap[ctrl_class | CTRL_REFRESH] = refreshBut;
115
 
        connect(refreshBut, SIGNAL(clicked()), sigMapper, SLOT(map()));
116
 
        sigMapper->setMapping(refreshBut, ctrl_class | CTRL_REFRESH);
117
 
 
118
 
        QPushButton *button = new QPushButton("Update", hbox);
119
 
        widgetMap[ctrl_class | CTRL_UPDATE] = button;
120
 
        connect(button, SIGNAL(clicked()), sigMapper, SLOT(map()));
121
 
        sigMapper->setMapping(button, ctrl_class | CTRL_UPDATE);
122
 
        connect(cbox, SIGNAL(toggled(bool)), button, SLOT(setDisabled(bool)));
123
 
 
124
 
        cbox->setChecked(ctrl_class == V4L2_CTRL_CLASS_USER);
125
 
 
126
 
        refresh(ctrl_class);
127
 
}
128
 
 
129
 
void ApplicationWindow::addCtrl(QGrid *grid, const struct v4l2_queryctrl &qctrl)
130
 
{
131
 
        QIntValidator *val;
132
 
        QLineEdit *edit;
133
 
        QString name((char *)qctrl.name);
134
 
        QComboBox *combo;
135
 
        struct v4l2_querymenu qmenu;
136
 
 
137
 
        QLabel *label = new QLabel(name, grid);
138
 
        label->setAlignment(Qt::AlignRight);
139
 
 
140
 
        switch (qctrl.type) {
141
 
        case V4L2_CTRL_TYPE_INTEGER:
142
 
                if (qctrl.flags & V4L2_CTRL_FLAG_SLIDER) {
143
 
                        widgetMap[qctrl.id] =
144
 
                                new QSlider(qctrl.minimum, qctrl.maximum,
145
 
                                        qctrl.step, qctrl.default_value,
146
 
                                        Horizontal, grid);
147
 
                        connect(widgetMap[qctrl.id], SIGNAL(valueChanged(int)),
148
 
                                sigMapper, SLOT(map()));
149
 
                        break;
150
 
                }
151
 
 
152
 
                if (qctrl.maximum - qctrl.minimum <= 255) {
153
 
                        widgetMap[qctrl.id] =
154
 
                                new QSpinBox(qctrl.minimum, qctrl.maximum, 1, grid);
155
 
                        connect(widgetMap[qctrl.id], SIGNAL(valueChanged(int)),
156
 
                                sigMapper, SLOT(map()));
157
 
                        break;
158
 
                }
159
 
 
160
 
                val = new QIntValidator(qctrl.minimum, qctrl.maximum, grid);
161
 
                edit = new QLineEdit(grid);
162
 
                edit->setValidator(val);
163
 
                widgetMap[qctrl.id] = edit;
164
 
                connect(widgetMap[qctrl.id], SIGNAL(lostFocus()),
165
 
                                sigMapper, SLOT(map()));
166
 
                connect(widgetMap[qctrl.id], SIGNAL(returnPressed()),
167
 
                                sigMapper, SLOT(map()));
168
 
                break;
169
 
 
170
 
        case V4L2_CTRL_TYPE_INTEGER64:
171
 
                widgetMap[qctrl.id] = new QLineEdit(grid);
172
 
                connect(widgetMap[qctrl.id], SIGNAL(lostFocus()),
173
 
                                sigMapper, SLOT(map()));
174
 
                connect(widgetMap[qctrl.id], SIGNAL(returnPressed()),
175
 
                                sigMapper, SLOT(map()));
176
 
                break;
177
 
 
178
 
        case V4L2_CTRL_TYPE_BOOLEAN:
179
 
                label->setText("");
180
 
                widgetMap[qctrl.id] = new QCheckBox(name, grid);
181
 
                connect(widgetMap[qctrl.id], SIGNAL(clicked()),
182
 
                                sigMapper, SLOT(map()));
183
 
                break;
184
 
 
185
 
        case V4L2_CTRL_TYPE_BUTTON:
186
 
                label->setText("");
187
 
                widgetMap[qctrl.id] = new QPushButton((char *)qctrl.name, grid);
188
 
                connect(widgetMap[qctrl.id], SIGNAL(clicked()),
189
 
                                sigMapper, SLOT(map()));
190
 
                break;
191
 
 
192
 
        case V4L2_CTRL_TYPE_MENU:
193
 
                combo = new QComboBox(grid);
194
 
                widgetMap[qctrl.id] = combo;
195
 
                for (int i = qctrl.minimum; i <= qctrl.maximum; i++) {
196
 
                        qmenu.id = qctrl.id;
197
 
                        qmenu.index = i;
198
 
                        if (::ioctl(fd, VIDIOC_QUERYMENU, &qmenu))
199
 
                                continue;
200
 
                        combo->insertItem((char *)qmenu.name);
201
 
                }
202
 
                connect(widgetMap[qctrl.id], SIGNAL(activated(int)),
203
 
                                sigMapper, SLOT(map()));
204
 
                break;
205
 
 
206
 
        default:
207
 
                return;
208
 
        }
209
 
        sigMapper->setMapping(widgetMap[qctrl.id], qctrl.id);
210
 
        if (qctrl.flags & (V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_INACTIVE))
211
 
                widgetMap[qctrl.id]->setDisabled(true);
212
 
}
213
 
 
214
 
void ApplicationWindow::ctrlAction(int id)
215
 
{
216
 
        unsigned ctrl_class = V4L2_CTRL_ID2CLASS(id);
217
 
        if (ctrl_class == V4L2_CID_PRIVATE_BASE)
218
 
                ctrl_class = V4L2_CTRL_CLASS_USER;
219
 
        unsigned ctrl = id & 0xffff;
220
 
        QCheckBox *cbox = static_cast<QCheckBox *>(widgetMap[ctrl_class | CTRL_UPDATE_ON_CHANGE]);
221
 
        bool update = cbox->isChecked();
222
 
        bool all = (ctrl == CTRL_UPDATE || (update && ctrl == CTRL_UPDATE_ON_CHANGE));
223
 
 
224
 
        if (ctrl == CTRL_DEFAULTS) {
225
 
                setDefaults(ctrl_class);
226
 
                return;
227
 
        }
228
 
        if (ctrl == CTRL_REFRESH) {
229
 
                refresh(ctrl_class);
230
 
                return;
231
 
        }
232
 
        if (!update && !all && ctrlMap[id].type != V4L2_CTRL_TYPE_BUTTON)
233
 
                return;
234
 
        if (ctrl_class == V4L2_CTRL_CLASS_USER) {
235
 
                if (!all) {
236
 
                        updateCtrl(id);
237
 
                        return;
238
 
                }
239
 
                for (unsigned i = 0; i < classMap[ctrl_class].size(); i++) {
240
 
                        updateCtrl(classMap[ctrl_class][i]);
241
 
                }
242
 
                return;
243
 
        }
244
 
        if (!all) {
245
 
                updateCtrl(id);
246
 
                return;
247
 
        }
248
 
        unsigned count = classMap[ctrl_class].size();
249
 
        struct v4l2_ext_control *c = new v4l2_ext_control[count];
250
 
        struct v4l2_ext_controls ctrls;
251
 
        int idx = 0;
252
 
 
253
 
        for (unsigned i = 0; i < count; i++) {
254
 
                unsigned id = classMap[ctrl_class][i];
255
 
 
256
 
                if (ctrlMap[id].flags & (V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_INACTIVE))
257
 
                        continue;
258
 
                c[idx].id = id;
259
 
                if (ctrlMap[id].type == V4L2_CTRL_TYPE_INTEGER64)
260
 
                        c[idx].value64 = getVal64(id);
261
 
                else
262
 
                        c[idx].value = getVal(id);
263
 
                idx++;
264
 
        }
265
 
        memset(&ctrls, 0, sizeof(ctrls));
266
 
        ctrls.count = idx;
267
 
        ctrls.ctrl_class = ctrl_class;
268
 
        ctrls.controls = c;
269
 
        if (::ioctl(fd, VIDIOC_S_EXT_CTRLS, &ctrls)) {
270
 
                int err = errno;
271
 
 
272
 
                if (ctrls.error_idx >= ctrls.count) {
273
 
                        printf("error: %s\n", strerror(err));
274
 
                }
275
 
                else {
276
 
                        id = c[ctrls.error_idx].id;
277
 
                        printf("error %08x (%s): %s\n", id,
278
 
                                        ctrlMap[id].name, strerror(err));
279
 
                }
280
 
        }
281
 
        delete [] c;
282
 
        refresh(ctrl_class);
283
 
}
284
 
 
285
 
long long ApplicationWindow::getVal64(unsigned id)
286
 
{
287
 
        const v4l2_queryctrl &qctrl = ctrlMap[id];
288
 
        QWidget *w = widgetMap[qctrl.id];
289
 
        long long v = 0;
290
 
 
291
 
        switch (qctrl.type) {
292
 
        case V4L2_CTRL_TYPE_INTEGER64:
293
 
                v = static_cast<QLineEdit *>(w)->text().toLongLong();
294
 
                break;
295
 
        default:
296
 
                break;
297
 
        }
298
 
        setWhat(w, id, v);
299
 
        return v;
300
 
}
301
 
 
302
 
int ApplicationWindow::getVal(unsigned id)
303
 
{
304
 
        const v4l2_queryctrl &qctrl = ctrlMap[id];
305
 
        QWidget *w = widgetMap[qctrl.id];
306
 
        v4l2_querymenu qmenu;
307
 
        int i, idx;
308
 
        int v = 0;
309
 
 
310
 
        switch (qctrl.type) {
311
 
        case V4L2_CTRL_TYPE_INTEGER:
312
 
                if (qctrl.flags & V4L2_CTRL_FLAG_SLIDER) {
313
 
                        v = static_cast<QSlider *>(w)->value();
314
 
                        break;
315
 
                }
316
 
 
317
 
                if (qctrl.maximum - qctrl.minimum <= 255) {
318
 
                        v = static_cast<QSpinBox *>(w)->value();
319
 
                        break;
320
 
                }
321
 
                v = static_cast<QLineEdit *>(w)->text().toInt();
322
 
                break;
323
 
 
324
 
        case V4L2_CTRL_TYPE_BOOLEAN:
325
 
                v = static_cast<QCheckBox *>(w)->isChecked();
326
 
                break;
327
 
 
328
 
        case V4L2_CTRL_TYPE_MENU:
329
 
                idx = static_cast<QComboBox *>(w)->currentItem();
330
 
                for (i = qctrl.minimum; i <= qctrl.maximum; i++) {
331
 
                        qmenu.id = qctrl.id;
332
 
                        qmenu.index = i;
333
 
                        if (::ioctl(fd, VIDIOC_QUERYMENU, &qmenu))
334
 
                                continue;
335
 
                        if (idx-- == 0)
336
 
                                break;
337
 
                }
338
 
                v = i;
339
 
                break;
340
 
 
341
 
        default:
342
 
                break;
343
 
        }
344
 
        setWhat(w, id, v);
345
 
        return v;
346
 
}
347
 
 
348
 
void ApplicationWindow::updateCtrl(unsigned id)
349
 
{
350
 
        unsigned ctrl_class = V4L2_CTRL_ID2CLASS(id);
351
 
        if (ctrl_class == V4L2_CID_PRIVATE_BASE)
352
 
                ctrl_class = V4L2_CTRL_CLASS_USER;
353
 
 
354
 
        if (ctrlMap[id].flags & (V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_INACTIVE))
355
 
                return;
356
 
 
357
 
        if (ctrl_class == V4L2_CTRL_CLASS_USER) {
358
 
                struct v4l2_control c;
359
 
 
360
 
                c.id = id;
361
 
                c.value = getVal(id);
362
 
                if (::ioctl(fd, VIDIOC_S_CTRL, &c)) {
363
 
                        int err = errno;
364
 
                        char buf[200];
365
 
 
366
 
                        sprintf(buf, "Error %08x (%s): %s", id,
367
 
                                ctrlMap[id].name, strerror(err));
368
 
                        statusBar()->message(buf, 10000);
369
 
                }
370
 
                return;
371
 
        }
372
 
        struct v4l2_ext_control c;
373
 
        struct v4l2_ext_controls ctrls;
374
 
 
375
 
        memset(&c, 0, sizeof(c));
376
 
        memset(&ctrls, 0, sizeof(ctrls));
377
 
        c.id = id;
378
 
        if (ctrlMap[id].type == V4L2_CTRL_TYPE_INTEGER64)
379
 
                c.value64 = getVal64(id);
380
 
        else
381
 
                c.value = getVal(id);
382
 
        ctrls.count = 1;
383
 
        ctrls.ctrl_class = ctrl_class;
384
 
        ctrls.controls = &c;
385
 
        if (::ioctl(fd, VIDIOC_S_EXT_CTRLS, &ctrls)) {
386
 
                int err = errno;
387
 
                char buf[200];
388
 
 
389
 
                sprintf(buf, "Error %08x (%s): %s", id,
390
 
                                ctrlMap[id].name, strerror(err));
391
 
                statusBar()->message(buf, 10000);
392
 
        }
393
 
        else if (ctrlMap[id].flags & V4L2_CTRL_FLAG_UPDATE)
394
 
                refresh(ctrl_class);
395
 
        else {
396
 
                if (ctrlMap[id].type == V4L2_CTRL_TYPE_INTEGER64)
397
 
                        setVal64(id, c.value64);
398
 
                else
399
 
                        setVal(id, c.value);
400
 
        }
401
 
}
402
 
 
403
 
void ApplicationWindow::refresh(unsigned ctrl_class)
404
 
{
405
 
        if (ctrl_class == V4L2_CTRL_CLASS_USER) {
406
 
                for (unsigned i = 0; i < classMap[ctrl_class].size(); i++) {
407
 
                        unsigned id = classMap[ctrl_class][i];
408
 
 
409
 
                        v4l2_control c;
410
 
 
411
 
                        c.id = id;
412
 
                        if (::ioctl(fd, VIDIOC_G_CTRL, &c)) {
413
 
                                int err = errno;
414
 
                                char buf[200];
415
 
 
416
 
                                sprintf(buf, "Error %08x (%s): %s", id,
417
 
                                                ctrlMap[id].name, strerror(err));
418
 
                                statusBar()->message(buf, 10000);
419
 
                        }
420
 
                        setVal(id, c.value);
421
 
                }
422
 
                return;
423
 
        }
424
 
        unsigned count = classMap[ctrl_class].size();
425
 
        struct v4l2_ext_control *c = new v4l2_ext_control[count];
426
 
        struct v4l2_ext_controls ctrls;
427
 
 
428
 
        for (unsigned i = 0; i < count; i++) {
429
 
                c[i].id = classMap[ctrl_class][i];
430
 
        }
431
 
        memset(&ctrls, 0, sizeof(ctrls));
432
 
        ctrls.count = count;
433
 
        ctrls.ctrl_class = ctrl_class;
434
 
        ctrls.controls = c;
435
 
        if (::ioctl(fd, VIDIOC_G_EXT_CTRLS, &ctrls)) {
436
 
                int err = errno;
437
 
 
438
 
                if (ctrls.error_idx >= ctrls.count) {
439
 
                        statusBar()->message(strerror(err), 10000);
440
 
                }
441
 
                else {
442
 
                        unsigned id = c[ctrls.error_idx].id;
443
 
                        char buf[200];
444
 
 
445
 
                        sprintf(buf, "Error %08x (%s): %s", id,
446
 
                                        ctrlMap[id].name, strerror(err));
447
 
                        statusBar()->message(buf, 10000);
448
 
                }
449
 
        }
450
 
        else {
451
 
                for (unsigned i = 0; i < ctrls.count; i++) {
452
 
                        unsigned id = c[i].id;
453
 
                        if (ctrlMap[id].type == V4L2_CTRL_TYPE_INTEGER64)
454
 
                                setVal64(id, c[i].value64);
455
 
                        else
456
 
                                setVal(id, c[i].value);
457
 
                        ::ioctl(fd, VIDIOC_QUERYCTRL, &ctrlMap[id]);
458
 
                        widgetMap[id]->setDisabled(ctrlMap[id].flags &
459
 
                                (V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_INACTIVE));
460
 
                }
461
 
        }
462
 
        delete [] c;
463
 
}
464
 
 
465
 
void ApplicationWindow::setWhat(QWidget *w, unsigned id, long long v)
466
 
{
467
 
        const v4l2_queryctrl &qctrl = ctrlMap[id];
468
 
        QString what;
469
 
        QString flags = getCtrlFlags(qctrl.flags);
470
 
 
471
 
        switch (qctrl.type) {
472
 
        case V4L2_CTRL_TYPE_INTEGER:
473
 
                QWhatsThis::add(w, what.sprintf("Integer type control\n"
474
 
                                        "Minimum: %d\n"
475
 
                                        "Maximum: %d\n"
476
 
                                        "Current: %d\n"
477
 
                                        "Default: %d\n",
478
 
                        qctrl.minimum, qctrl.maximum, (int)v, qctrl.default_value) + flags);
479
 
                break;
480
 
 
481
 
        case V4L2_CTRL_TYPE_INTEGER64:
482
 
                QWhatsThis::add(w, what.sprintf("64-bit Integer type control\n"
483
 
                                        "Current: %lld\n", v) + flags);
484
 
                break;
485
 
 
486
 
        case V4L2_CTRL_TYPE_BUTTON:
487
 
                QWhatsThis::add(w, what.sprintf("Button type control\n") + flags);
488
 
                break;
489
 
 
490
 
        case V4L2_CTRL_TYPE_BOOLEAN:
491
 
                QWhatsThis::add(w, what.sprintf("Boolean type control\n"
492
 
                                        "Current: %d\n"
493
 
                                        "Default: %d\n",
494
 
                        (int)v, qctrl.default_value) + flags);
495
 
                break;
496
 
 
497
 
        case V4L2_CTRL_TYPE_MENU:
498
 
                QWhatsThis::add(w, what.sprintf("Menu type control\n"
499
 
                                        "Minimum: %d\n"
500
 
                                        "Maximum: %d\n"
501
 
                                        "Current: %d\n"
502
 
                                        "Default: %d\n",
503
 
                        qctrl.minimum, qctrl.maximum, (int)v, qctrl.default_value) + flags);
504
 
                break;
505
 
        default:
506
 
                break;
507
 
        }
508
 
}
509
 
 
510
 
void ApplicationWindow::setVal(unsigned id, int v)
511
 
{
512
 
        const v4l2_queryctrl &qctrl = ctrlMap[id];
513
 
        v4l2_querymenu qmenu;
514
 
        QWidget *w = widgetMap[qctrl.id];
515
 
        int i, idx;
516
 
 
517
 
        switch (qctrl.type) {
518
 
        case V4L2_CTRL_TYPE_INTEGER:
519
 
                if (qctrl.flags & V4L2_CTRL_FLAG_SLIDER)
520
 
                        static_cast<QSlider *>(w)->setValue(v);
521
 
                else if (qctrl.maximum - qctrl.minimum <= 255)
522
 
                        static_cast<QSpinBox *>(w)->setValue(v);
523
 
                else
524
 
                        static_cast<QLineEdit *>(w)->setText(QString::number(v));
525
 
                break;
526
 
 
527
 
        case V4L2_CTRL_TYPE_BOOLEAN:
528
 
                static_cast<QCheckBox *>(w)->setChecked(v);
529
 
                break;
530
 
 
531
 
        case V4L2_CTRL_TYPE_MENU:
532
 
                idx = 0;
533
 
                for (i = qctrl.minimum; i <= v; i++) {
534
 
                        qmenu.id = id;
535
 
                        qmenu.index = i;
536
 
                        if (::ioctl(fd, VIDIOC_QUERYMENU, &qmenu))
537
 
                                continue;
538
 
                        idx++;
539
 
                }
540
 
                static_cast<QComboBox *>(w)->setCurrentItem(idx - 1);
541
 
                break;
542
 
        default:
543
 
                break;
544
 
        }
545
 
        setWhat(w, id, v);
546
 
}
547
 
 
548
 
void ApplicationWindow::setVal64(unsigned id, long long v)
549
 
{
550
 
        const v4l2_queryctrl &qctrl = ctrlMap[id];
551
 
        QWidget *w = widgetMap[qctrl.id];
552
 
 
553
 
        switch (qctrl.type) {
554
 
        case V4L2_CTRL_TYPE_INTEGER64:
555
 
                static_cast<QLineEdit *>(w)->setText(QString::number(v));
556
 
                break;
557
 
        default:
558
 
                break;
559
 
        }
560
 
        setWhat(w, id, v);
561
 
}
562
 
 
563
 
void ApplicationWindow::setDefaults(unsigned ctrl_class)
564
 
{
565
 
        for (unsigned i = 0; i < classMap[ctrl_class].size(); i++) {
566
 
                unsigned id = classMap[ctrl_class][i];
567
 
 
568
 
                if (ctrlMap[id].type != V4L2_CTRL_TYPE_INTEGER64 &&
569
 
                    ctrlMap[id].type != V4L2_CTRL_TYPE_BUTTON)
570
 
                        setVal(id, ctrlMap[id].default_value);
571
 
        }
572
 
        ctrlAction(ctrl_class | CTRL_UPDATE);
573
 
}
574
 
 
575
 
QString ApplicationWindow::getCtrlFlags(unsigned flags)
576
 
{
577
 
        QString s;
578
 
 
579
 
        if (flags & V4L2_CTRL_FLAG_GRABBED)
580
 
                s += "grabbed ";
581
 
        if (flags & V4L2_CTRL_FLAG_READ_ONLY)
582
 
                s += "readonly ";
583
 
        if (flags & V4L2_CTRL_FLAG_UPDATE)
584
 
                s += "update ";
585
 
        if (flags & V4L2_CTRL_FLAG_INACTIVE)
586
 
                s += "inactive ";
587
 
        if (flags & V4L2_CTRL_FLAG_SLIDER)
588
 
                s += "slider ";
589
 
        if (s.length()) s = QString("Flags: ") + s;
590
 
        return s;
591
 
}
592