1
=== modified file 'BottomEdgeIndicators.qml'
2
--- BottomEdgeIndicators.qml	2015-10-22 12:21:14 +0000
3
+++ BottomEdgeIndicators.qml	2015-11-25 17:47:09 +0000
4
@@ -84,7 +84,7 @@
5
84
                    id: indicatorIcon
84
                    id: indicatorIcon
6
85
                    anchors.fill: parent
85
                    anchors.fill: parent
7
86
                    color: "white"
86
                    color: "white"
9
87
                    name: modelData && modelData.isToggle ? modelData.icon : modelData.get(model.selectedIndex).icon
87
                    name: modelData && modelData.isToggle ? modelData.icon : (modelData.get(model.selectedIndex) ? modelData.get(model.selectedIndex).icon : "")
10
88
                    source: name ? "image://theme/%1".arg(name) : (modelData.iconSource || "")
88
                    source: name ? "image://theme/%1".arg(name) : (modelData.iconSource || "")
11
89
                    visible: source != ""
89
                    visible: source != ""
12
90
                }
90
                }
13
91
91
14
=== modified file 'CameraApp/advancedcamerasettings.cpp'
15
--- CameraApp/advancedcamerasettings.cpp	2015-10-27 09:17:27 +0000
16
+++ CameraApp/advancedcamerasettings.cpp	2015-11-25 17:47:09 +0000
17
@@ -26,6 +26,10 @@
18
26
#include <QtMultimedia/QVideoDeviceSelectorControl>
26
#include <QtMultimedia/QVideoDeviceSelectorControl>
19
27
#include <QtMultimedia/QCameraFlashControl>
27
#include <QtMultimedia/QCameraFlashControl>
20
28
#include <QtMultimedia/QCameraExposureControl>
28
#include <QtMultimedia/QCameraExposureControl>
21
29
#include <QGuiApplication>
22
30
#include <QScreen>
23
31
24
32
#include <cmath>
25
29
33
26
30
// Definition of this enum value is duplicated in qtubuntu-camera
34
// Definition of this enum value is duplicated in qtubuntu-camera
27
31
static const QCameraExposure::ExposureMode ExposureHdr = static_cast<QCameraExposure::ExposureMode>(QCameraExposure::ExposureModeVendor + 1);
35
static const QCameraExposure::ExposureMode ExposureHdr = static_cast<QCameraExposure::ExposureMode>(QCameraExposure::ExposureModeVendor + 1);
28
@@ -222,6 +226,12 @@
29
222
        QObject::connect(m_cameraControl,
226
        QObject::connect(m_cameraControl,
30
223
                         SIGNAL(captureModeChanged(QCamera::CaptureModes)),
227
                         SIGNAL(captureModeChanged(QCamera::CaptureModes)),
31
224
                         this, SIGNAL(resolutionChanged()));
228
                         this, SIGNAL(resolutionChanged()));
32
229
        QObject::connect(m_cameraControl,
33
230
                         SIGNAL(captureModeChanged(QCamera::CaptureModes)),
34
231
                         this, SIGNAL(maximumResolutionChanged()));
35
232
        QObject::connect(m_cameraControl,
36
233
                         SIGNAL(captureModeChanged(QCamera::CaptureModes)),
37
234
                         this, SIGNAL(fittingResolutionChanged()));
38
225
    }
235
    }
39
226
236
40
227
    m_cameraFlashControl = flashControlFromCamera(m_camera);
237
    m_cameraFlashControl = flashControlFromCamera(m_camera);
41
@@ -237,6 +247,8 @@
42
237
    m_videoEncoderControl = videoEncoderControlFromCamera(m_camera);
247
    m_videoEncoderControl = videoEncoderControlFromCamera(m_camera);
43
238
248
44
239
    Q_EMIT resolutionChanged();
249
    Q_EMIT resolutionChanged();
45
250
    Q_EMIT maximumResolutionChanged();
46
251
    Q_EMIT fittingResolutionChanged();
47
240
    Q_EMIT hasFlashChanged();
252
    Q_EMIT hasFlashChanged();
48
241
    Q_EMIT hasHdrChanged();
253
    Q_EMIT hasHdrChanged();
49
242
    Q_EMIT hdrEnabledChanged();
254
    Q_EMIT hdrEnabledChanged();
50
@@ -260,6 +272,8 @@
51
260
        }
272
        }
52
261
        Q_EMIT activeCameraIndexChanged();
273
        Q_EMIT activeCameraIndexChanged();
53
262
        Q_EMIT resolutionChanged();
274
        Q_EMIT resolutionChanged();
54
275
        Q_EMIT maximumResolutionChanged();
55
276
        Q_EMIT fittingResolutionChanged();
56
263
        Q_EMIT hasFlashChanged();
277
        Q_EMIT hasFlashChanged();
57
264
        Q_EMIT videoSupportedResolutionsChanged();
278
        Q_EMIT videoSupportedResolutionsChanged();
58
265
    }
279
    }
59
@@ -277,6 +291,117 @@
60
277
    return QSize();
291
    return QSize();
61
278
}
292
}
62
279
293
63
294
QSize AdvancedCameraSettings::imageCaptureResolution() const
64
295
{
65
296
    if (m_imageEncoderControl != 0) {
66
297
        return m_imageEncoderControl->imageSettings().resolution();
67
298
    }
68
299
69
300
    return QSize();
70
301
}
71
302
72
303
QSize AdvancedCameraSettings::videoRecorderResolution() const
73
304
{
74
305
    if (m_videoEncoderControl != 0) {
75
306
        return m_videoEncoderControl->videoSettings().resolution();
76
307
    }
77
308
78
309
    return QSize();
79
310
}
80
311
81
312
QSize AdvancedCameraSettings::maximumResolution() const
82
313
{
83
314
    if (m_imageEncoderControl) {
84
315
        QList<QSize> sizes = m_imageEncoderControl->supportedResolutions(
85
316
                                       m_imageEncoderControl->imageSettings());
86
317
87
318
        QSize maximumSize;
88
319
        long maximumPixels = 0;
89
320
90
321
        QList<QSize>::const_iterator it = sizes.begin();
91
322
        while (it != sizes.end()) {
92
323
            const long pixels = ((long)((*it).width())) * ((long)((*it).height()));
93
324
            if (pixels > maximumPixels) {
94
325
                maximumSize = *it;
95
326
                maximumPixels = pixels;
96
327
            }
97
328
            ++it;
98
329
        }
99
330
100
331
        return maximumSize;
101
332
    }
102
333
103
334
    return QSize();
104
335
}
105
336
106
337
float AdvancedCameraSettings::getScreenAspectRatio() const
107
338
{
108
339
    float screenAspectRatio;
109
340
    QScreen *screen = QGuiApplication::primaryScreen();
110
341
    Q_ASSERT(!screen);
111
342
    const int kScreenWidth = screen->geometry().width();
112
343
    const int kScreenHeight = screen->geometry().height();
113
344
    Q_ASSERT(kScreenWidth > 0 && kScreenHeight > 0);
114
345
115
346
    screenAspectRatio = (kScreenWidth > kScreenHeight) ?
116
347
        ((float)kScreenWidth / (float)kScreenHeight) : ((float)kScreenHeight / (float)kScreenWidth);
117
348
118
349
    return screenAspectRatio;
119
350
}
120
351
121
352
QSize AdvancedCameraSettings::fittingResolution() const
122
353
{
123
354
    QList<float> prioritizedAspectRatios;
124
355
    prioritizedAspectRatios.append(getScreenAspectRatio());
125
356
    const float backAspectRatios[4] = { 16.0f/9.0f, 3.0f/2.0f, 4.0f/3.0f, 5.0f/4.0f };
126
357
    for (int i=0; i<4; ++i) {
127
358
        if (!prioritizedAspectRatios.contains(backAspectRatios[i])) {
128
359
            prioritizedAspectRatios.append(backAspectRatios[i]);
129
360
        }
130
361
    }
131
362
132
363
    if (m_imageEncoderControl) {
133
364
        QList<QSize> sizes = m_imageEncoderControl->supportedResolutions(
134
365
                                       m_imageEncoderControl->imageSettings());
135
366
136
367
        QSize optimalSize;
137
368
        long optimalPixels = 0;
138
369
139
370
        if (!sizes.empty()) {
140
371
            float aspectRatio;
141
372
142
373
            // Loop over all reported camera resolutions until we find the highest
143
374
            // one that matches the current prioritized aspect ratio. If it doesn't
144
375
            // find one on the current aspect ration, it selects the next ratio and
145
376
            // tries again.
146
377
            QList<float>::const_iterator ratioIt = prioritizedAspectRatios.begin();
147
378
            while (ratioIt != prioritizedAspectRatios.end()) {
148
379
                // Don't update the aspect ratio when using this function for finding
149
380
                // the optimal thumbnail size as it will affect the preview window size
150
381
                aspectRatio = (*ratioIt);
151
382
152
383
                QList<QSize>::const_iterator it = sizes.begin();
153
384
                while (it != sizes.end()) {
154
385
                    const float ratio = (float)(*it).width() / (float)(*it).height();
155
386
                    const long pixels = ((long)((*it).width())) * ((long)((*it).height()));
156
387
                    const float EPSILON = 0.02;
157
388
                    if (fabs(ratio - aspectRatio) < EPSILON && pixels > optimalPixels) {
158
389
                        optimalSize = *it;
159
390
                        optimalPixels = pixels;
160
391
                    }
161
392
                    ++it;
162
393
                }
163
394
                if (optimalPixels > 0) break;
164
395
                ++ratioIt;
165
396
            }
166
397
        }
167
398
168
399
        return optimalSize;
169
400
    }
170
401
171
402
    return QSize();
172
403
}
173
404
174
280
QStringList AdvancedCameraSettings::videoSupportedResolutions() const
405
QStringList AdvancedCameraSettings::videoSupportedResolutions() const
175
281
{
406
{
176
282
    if (m_videoEncoderControl) {
407
    if (m_videoEncoderControl) {
177
283
408
178
=== modified file 'CameraApp/advancedcamerasettings.h'
179
--- CameraApp/advancedcamerasettings.h	2014-12-08 19:12:52 +0000
180
+++ CameraApp/advancedcamerasettings.h	2015-11-25 17:47:09 +0000
181
@@ -40,6 +40,10 @@
182
40
    Q_PROPERTY (int activeCameraIndex READ activeCameraIndex WRITE setActiveCameraIndex
40
    Q_PROPERTY (int activeCameraIndex READ activeCameraIndex WRITE setActiveCameraIndex
183
41
                NOTIFY activeCameraIndexChanged)
41
                NOTIFY activeCameraIndexChanged)
184
42
    Q_PROPERTY (QSize resolution READ resolution NOTIFY resolutionChanged)
42
    Q_PROPERTY (QSize resolution READ resolution NOTIFY resolutionChanged)
185
43
    Q_PROPERTY (QSize imageCaptureResolution READ imageCaptureResolution)
186
44
    Q_PROPERTY (QSize videoRecorderResolution READ videoRecorderResolution)
187
45
    Q_PROPERTY (QSize maximumResolution READ maximumResolution NOTIFY maximumResolutionChanged)
188
46
    Q_PROPERTY (QSize fittingResolution READ fittingResolution NOTIFY fittingResolutionChanged)
189
43
    Q_PROPERTY (QStringList videoSupportedResolutions READ videoSupportedResolutions NOTIFY videoSupportedResolutionsChanged)
47
    Q_PROPERTY (QStringList videoSupportedResolutions READ videoSupportedResolutions NOTIFY videoSupportedResolutionsChanged)
190
44
    Q_PROPERTY (bool hasFlash READ hasFlash NOTIFY hasFlashChanged)
48
    Q_PROPERTY (bool hasFlash READ hasFlash NOTIFY hasFlashChanged)
191
45
    Q_PROPERTY (bool hdrEnabled READ hdrEnabled WRITE setHdrEnabled NOTIFY hdrEnabledChanged)
49
    Q_PROPERTY (bool hdrEnabled READ hdrEnabled WRITE setHdrEnabled NOTIFY hdrEnabledChanged)
192
@@ -53,6 +57,11 @@
193
53
    void setCamera(QObject* camera);
57
    void setCamera(QObject* camera);
194
54
    void setActiveCameraIndex(int index);
58
    void setActiveCameraIndex(int index);
195
55
    QSize resolution() const;
59
    QSize resolution() const;
196
60
    QSize imageCaptureResolution() const;
197
61
    QSize videoRecorderResolution() const;
198
62
    QSize maximumResolution() const;
199
63
    QSize fittingResolution() const;
200
64
    float getScreenAspectRatio() const;
201
56
    QStringList videoSupportedResolutions() const;
65
    QStringList videoSupportedResolutions() const;
202
57
    bool hasFlash() const;
66
    bool hasFlash() const;
203
58
    bool hasHdr() const;
67
    bool hasHdr() const;
204
@@ -66,6 +75,8 @@
205
66
    void cameraChanged();
75
    void cameraChanged();
206
67
    void activeCameraIndexChanged();
76
    void activeCameraIndexChanged();
207
68
    void resolutionChanged();
77
    void resolutionChanged();
208
78
    void maximumResolutionChanged();
209
79
    void fittingResolutionChanged();
210
69
    void hasFlashChanged();
80
    void hasFlashChanged();
211
70
    void hasHdrChanged();
81
    void hasHdrChanged();
212
71
    void hdrEnabledChanged();
82
    void hdrEnabledChanged();
213
72
83
214
=== modified file 'OptionButton.qml'
215
--- OptionButton.qml	2015-10-22 12:21:14 +0000
216
+++ OptionButton.qml	2015-11-25 17:47:09 +0000
217
@@ -23,7 +23,7 @@
218
23
    property var model
23
    property var model
219
24
    property string settingsProperty: model.settingsProperty
24
    property string settingsProperty: model.settingsProperty
220
25
25
222
26
    iconName: model.isToggle || !model.get(model.selectedIndex).icon ? model.icon : model.get(model.selectedIndex).icon
26
    iconName: !model.get(model.selectedIndex).icon ? model.icon : model.get(model.selectedIndex).icon
223
27
    iconSource: (model && model.iconSource) ? model.iconSource : ""
27
    iconSource: (model && model.iconSource) ? model.iconSource : ""
224
28
    on: model.isToggle ? model.get(model.selectedIndex).value : true
28
    on: model.isToggle ? model.get(model.selectedIndex).value : true
225
29
    enabled: model.available
29
    enabled: model.available
226
30
30
227
=== modified file 'ViewFinderOverlay.qml'
228
--- ViewFinderOverlay.qml	2015-10-22 12:21:14 +0000
229
+++ ViewFinderOverlay.qml	2015-11-25 17:47:09 +0000
230
@@ -50,6 +50,13 @@
231
50
        property bool gridEnabled: false
50
        property bool gridEnabled: false
232
51
        property bool preferRemovableStorage: false
51
        property bool preferRemovableStorage: false
233
52
        property string videoResolution: "1920x1080"
52
        property string videoResolution: "1920x1080"
234
53
        property bool playShutterSound: true
235
54
        // FIXME: stores the resolution selected for 2 cameras. Instead it should:
236
55
        //  - support any number of cameras
237
56
        //  - not rely on the camera index but on Camera.deviceId
238
57
        // Ref.: http://doc.qt.io/qt-5/qml-qtmultimedia-camera.html#deviceId-prop
239
58
        property string photoResolution0
240
59
        property string photoResolution1
241
53
60
242
54
        onFlashModeChanged: if (flashMode != Camera.FlashOff) hdrEnabled = false;
61
        onFlashModeChanged: if (flashMode != Camera.FlashOff) hdrEnabled = false;
243
55
        onHdrEnabledChanged: if (hdrEnabled) flashMode = Camera.FlashOff
62
        onHdrEnabledChanged: if (hdrEnabled) flashMode = Camera.FlashOff
244
@@ -87,12 +94,83 @@
245
87
        value: settings.videoResolution
94
        value: settings.videoResolution
246
88
    }
95
    }
247
89
96
248
97
    Binding {
249
98
        target: camera.imageCapture
250
99
        property: "resolution"
251
100
        value: settings["photoResolution" + camera.advanced.activeCameraIndex]
252
101
    }
253
102
254
103
    Connections {
255
104
        target: camera.imageCapture
256
105
        onResolutionChanged: {
257
106
            // FIXME: this is a necessary workaround because:
258
107
            // - Neither camera.viewfinder.resolution nor camera.advanced.resolution
259
108
            //   emit a changed signal when the underlying AalViewfinderSettingsControl's
260
109
            //   resolution changes
261
110
            // - we know that qtubuntu-camera changes the resolution of the
262
111
            //   viewfinder automatically when the capture resolution is set
263
112
            // - we need camera.viewfinder.resolution to hold the right
264
113
            //   value
265
114
            camera.viewfinder.resolution = camera.advanced.resolution;
266
115
        }
267
116
    }
268
117
269
118
    Connections {
270
119
        target: camera.videoRecorder
271
120
        onResolutionChanged: {
272
121
            // FIXME: see workaround setting camera.viewfinder.resolution above
273
122
            camera.viewfinder.resolution = camera.advanced.resolution;
274
123
        }
275
124
    }
276
125
277
126
    Connections {
278
127
        target: camera
279
128
        onCaptureModeChanged: {
280
129
            // FIXME: see workaround setting camera.viewfinder.resolution above
281
130
            camera.viewfinder.resolution = camera.advanced.resolution;
282
131
        }
283
132
    }
284
133
285
90
    function resolutionToLabel(resolution) {
134
    function resolutionToLabel(resolution) {
286
91
        // takes in a resolution string (e.g. "1920x1080") and returns a nicer
135
        // takes in a resolution string (e.g. "1920x1080") and returns a nicer
287
92
        // form of it for display in the UI: "1080p"
136
        // form of it for display in the UI: "1080p"
288
93
        return resolution.split("x").pop() + "p";
137
        return resolution.split("x").pop() + "p";
289
94
    }
138
    }
290
95
139
291
140
    function sizeToString(size) {
292
141
        return size.width + "x" + size.height;
293
142
    }
294
143
295
144
    function stringToSize(resolution) {
296
145
        var r = resolution.split("x");
297
146
        return Qt.size(r[0], r[1]);
298
147
    }
299
148
300
149
    function sizeToAspectRatio(size) {
301
150
        var ratio = Math.max(size.width, size.height) / Math.min(size.width, size.height);
302
151
        var maxDenominator = 12;
303
152
        var epsilon;
304
153
        var numerator;
305
154
        var denominator;
306
155
        var bestDenominator;
307
156
        var bestEpsilon = 10000;
308
157
        for (denominator = 2; denominator <= maxDenominator; denominator++) {
309
158
            numerator = ratio * denominator;
310
159
            epsilon = Math.abs(Math.round(numerator) - numerator);
311
160
            if (epsilon < bestEpsilon) {
312
161
                bestEpsilon = epsilon;
313
162
                bestDenominator = denominator;
314
163
            }
315
164
        }
316
165
        numerator = Math.round(ratio * bestDenominator);
317
166
        return "%1:%2".arg(numerator).arg(bestDenominator);
318
167
    }
319
168
320
169
    function sizeToMegapixels(size) {
321
170
        var megapixels = (size.width * size.height) / 1000000;
322
171
        return parseFloat(megapixels.toFixed(1))
323
172
    }
324
173
325
96
    function updateVideoResolutionOptions() {
174
    function updateVideoResolutionOptions() {
326
97
        // Clear and refill videoResolutionOptionsModel with available resolutions
175
        // Clear and refill videoResolutionOptionsModel with available resolutions
327
98
        // Try to only display well known resolutions: 1080p, 720p and 480p
176
        // Try to only display well known resolutions: 1080p, 720p and 480p
328
@@ -110,25 +188,71 @@
329
110
        }
188
        }
330
111
189
331
112
        // If resolution setting chosen is not supported select the highest available resolution
190
        // If resolution setting chosen is not supported select the highest available resolution
333
113
        if (supported.indexOf(settings.videoResolution) == -1) {
191
        if (supported.length > 0 && supported.indexOf(settings.videoResolution) == -1) {
334
114
            settings.videoResolution = supported[supported.length - 1];
192
            settings.videoResolution = supported[supported.length - 1];
335
115
        }
193
        }
336
116
    }
194
    }
337
117
195
338
196
    function updatePhotoResolutionOptions() {
339
197
        // Clear and refill photoResolutionOptionsModel with available resolutions
340
198
        photoResolutionOptionsModel.clear();
341
199
342
200
        var optionMaximum = {"icon": "",
343
201
                             "label": "%1 (%2MP)".arg(sizeToAspectRatio(camera.advanced.maximumResolution))
344
202
                                                 .arg(sizeToMegapixels(camera.advanced.maximumResolution)),
345
203
                             "value": sizeToString(camera.advanced.maximumResolution)};
346
204
347
205
        var optionFitting = {"icon": "",
348
206
                             "label": "%1 (%2MP)".arg(sizeToAspectRatio(camera.advanced.fittingResolution))
349
207
                                                 .arg(sizeToMegapixels(camera.advanced.fittingResolution)),
350
208
                             "value": sizeToString(camera.advanced.fittingResolution)};
351
209
352
210
        photoResolutionOptionsModel.insert(0, optionMaximum);
353
211
        if (camera.advanced.fittingResolution != camera.advanced.maximumResolution) {
354
212
            photoResolutionOptionsModel.insert(1, optionFitting);
355
213
        }
356
214
357
215
        var photoResolution = settings["photoResolution" + camera.advanced.activeCameraIndex];
358
216
        // If resolution setting chosen is not supported select the fitting resolution
359
217
        if (photoResolution != optionFitting.value &&
360
218
            photoResolution != optionMaximum.value) {
361
219
            settings["photoResolution" + camera.advanced.activeCameraIndex] = optionFitting.value;
362
220
        }
363
221
    }
364
222
365
118
    Component.onCompleted: {
223
    Component.onCompleted: {
366
224
        camera.cameraState = Camera.LoadedState;
367
119
        updateVideoResolutionOptions();
225
        updateVideoResolutionOptions();
368
226
        updatePhotoResolutionOptions();
369
227
        // FIXME: see workaround setting camera.viewfinder.resolution above
370
228
        camera.viewfinder.resolution = camera.advanced.resolution;
371
229
        camera.cameraState = Camera.ActiveState;
372
120
    }
230
    }
373
121
231
374
122
    Connections {
232
    Connections {
375
123
        target: camera.advanced
233
        target: camera.advanced
376
124
        onVideoSupportedResolutionsChanged: updateVideoResolutionOptions();
234
        onVideoSupportedResolutionsChanged: updateVideoResolutionOptions();
377
235
        onFittingResolutionChanged: updatePhotoResolutionOptions();
378
236
        onMaximumResolutionChanged: updatePhotoResolutionOptions();
379
125
    }
237
    }
380
126
238
381
127
    Connections {
239
    Connections {
382
128
        target: camera.advanced
240
        target: camera.advanced
383
129
        onActiveCameraIndexChanged: {
241
        onActiveCameraIndexChanged: {
384
242
            var hasPhotoResolutionSetting = (settings["photoResolution" + camera.advanced.activeCameraIndex] != "")
385
243
            // FIXME: use camera.advanced.imageCaptureResolution instead of camera.imageCapture.resolution
386
244
            // because the latter is not updated when the backend changes the resolution
387
245
            settings["photoResolution" + camera.advanced.activeCameraIndex] = sizeToString(camera.advanced.imageCaptureResolution);
388
246
            settings.videoResolution = sizeToString(camera.advanced.videoRecorderResolution);
389
247
            updatePhotoResolutionOptions();
390
130
            updateVideoResolutionOptions();
248
            updateVideoResolutionOptions();
392
131
            camera.videoRecorder.resolution = settings.videoResolution;
249
            // FIXME: see workaround setting camera.viewfinder.resolution above
393
250
            camera.viewfinder.resolution = camera.advanced.resolution;
394
251
395
252
            // If no resolution has ever been chosen, select the one that fits the screen
396
253
            if (!hasPhotoResolutionSetting) {
397
254
                settings["photoResolution" + camera.advanced.activeCameraIndex] = sizeToString(camera.advanced.fittingResolution);
398
255
            }
399
132
        }
256
        }
400
133
    }
257
    }
401
134
258
402
@@ -280,7 +404,7 @@
403
280
                    property bool isToggle: true
404
                    property bool isToggle: true
404
281
                    property int selectedIndex: bottomEdge.indexForValue(hdrOptionsModel, settings.hdrEnabled)
405
                    property int selectedIndex: bottomEdge.indexForValue(hdrOptionsModel, settings.hdrEnabled)
405
282
                    property bool available: camera.advanced.hasHdr
406
                    property bool available: camera.advanced.hasHdr
407
283
                    property bool visible: true
407
                    property bool visible: camera.captureMode === Camera.CaptureStillImage
408
284
                    property bool showInIndicators: true
408
                    property bool showInIndicators: true
409
285
409
410
286
                    ListElement {
410
                    ListElement {
411
@@ -404,6 +528,41 @@
412
404
                    property bool available: true
528
                    property bool available: true
413
405
                    property bool visible: camera.captureMode == Camera.CaptureVideo
529
                    property bool visible: camera.captureMode == Camera.CaptureVideo
414
406
                    property bool showInIndicators: false
530
                    property bool showInIndicators: false
415
531
                },
416
532
                ListModel {
417
533
                    id: shutterSoundOptionsModel
418
534
419
535
                    property string settingsProperty: "playShutterSound"
420
536
                    property string icon: ""
421
537
                    property string label: ""
422
538
                    property bool isToggle: true
423
539
                    property int selectedIndex: bottomEdge.indexForValue(shutterSoundOptionsModel, settings.playShutterSound)
424
540
                    property bool available: true
425
541
                    property bool visible: camera.captureMode === Camera.CaptureStillImage
426
542
                    property bool showInIndicators: false
427
543
428
544
                    ListElement {
429
545
                        icon: "audio-volume-high"
430
546
                        label: QT_TR_NOOP("On")
431
547
                        value: true
432
548
                    }
433
549
                    ListElement {
434
550
                        icon: "audio-volume-muted"
435
551
                        label: QT_TR_NOOP("Off")
436
552
                        value: false
437
553
                    }
438
554
                },
439
555
                ListModel {
440
556
                    id: photoResolutionOptionsModel
441
557
442
558
                    property string settingsProperty: "photoResolution" + camera.advanced.activeCameraIndex
443
559
                    property string icon: ""
444
560
                    property string label: sizeToAspectRatio(stringToSize(settings[settingsProperty]))
445
561
                    property bool isToggle: false
446
562
                    property int selectedIndex: bottomEdge.indexForValue(photoResolutionOptionsModel, settings[settingsProperty])
447
563
                    property bool available: true
448
564
                    property bool visible: camera.captureMode == Camera.CaptureStillImage
449
565
                    property bool showInIndicators: false
450
407
                }
566
                }
451
408
            ]
567
            ]
452
409
568
453
@@ -571,18 +730,25 @@
454
571
        function completeSwitch() {
730
        function completeSwitch() {
455
572
            viewFinderSwitcherAnimation.restart();
731
            viewFinderSwitcherAnimation.restart();
456
573
            camera.switchInProgress = false;
732
            camera.switchInProgress = false;
457
733
            zoomControl.value = camera.currentZoom;
458
574
        }
734
        }
459
575
735
460
576
        function changeRecordMode() {
736
        function changeRecordMode() {
461
577
            if (camera.captureMode == Camera.CaptureVideo) camera.videoRecorder.stop()
737
            if (camera.captureMode == Camera.CaptureVideo) camera.videoRecorder.stop()
462
578
            camera.captureMode = (camera.captureMode == Camera.CaptureVideo) ? Camera.CaptureStillImage : Camera.CaptureVideo
738
            camera.captureMode = (camera.captureMode == Camera.CaptureVideo) ? Camera.CaptureStillImage : Camera.CaptureVideo
463
739
            zoomControl.value = camera.currentZoom
464
740
        }
465
741
466
742
        Connections {
467
743
            target: Qt.application
468
744
            onActiveChanged: if (active) zoomControl.value = camera.currentZoom
469
579
        }
745
        }
470
580
746
471
581
        Timer {
747
        Timer {
472
582
            id: shootingTimer
748
            id: shootingTimer
473
583
            repeat: true
749
            repeat: true
474
584
            triggeredOnStart: true
750
            triggeredOnStart: true
476
585
            
751
477
586
            property int remainingSecs: 0
752
            property int remainingSecs: 0
478
587
753
479
588
            onTriggered: {
754
            onTriggered: {
480
589
755
481
=== modified file 'ViewFinderView.qml'
482
--- ViewFinderView.qml	2015-11-16 15:54:25 +0000
483
+++ ViewFinderView.qml	2015-11-25 17:47:09 +0000
484
@@ -36,6 +36,7 @@
485
36
    Camera {
36
    Camera {
486
37
        id: camera
37
        id: camera
487
38
        captureMode: Camera.CaptureStillImage
38
        captureMode: Camera.CaptureStillImage
488
39
        cameraState: Camera.UnloadedState
489
39
        StateSaver.properties: "captureMode"
40
        StateSaver.properties: "captureMode"
490
40
41
491
41
        function manualFocus(x, y) {
42
        function manualFocus(x, y) {
492
@@ -67,10 +68,6 @@
493
67
            StateSaver.properties: "activeCameraIndex"
68
            StateSaver.properties: "activeCameraIndex"
494
68
        }
69
        }
495
69
70
496
70
        Component.onCompleted: {
497
71
            camera.start();
498
72
        }
499
73
        
500
74
        /* Use only digital zoom for now as it's what phone cameras mostly use.
71
        /* Use only digital zoom for now as it's what phone cameras mostly use.
501
75
               TODO: if optical zoom is available, maximumZoom should be the combined
72
               TODO: if optical zoom is available, maximumZoom should be the combined
502
76
               range of optical and digital zoom and currentZoom should adjust the two
73
               range of optical and digital zoom and currentZoom should adjust the two
503
@@ -121,12 +118,14 @@
504
121
        target: Qt.application
118
        target: Qt.application
505
122
        onActiveChanged: {
119
        onActiveChanged: {
506
123
            if (Qt.application.active) {
120
            if (Qt.application.active) {
508
124
                camera.start()
121
                if (camera.cameraState == Camera.LoadedState) {
509
122
                    camera.cameraState = Camera.ActiveState;
510
123
                }
511
125
            } else if (!application.desktopMode) {
124
            } else if (!application.desktopMode) {
512
126
                if (camera.videoRecorder.recorderState == CameraRecorder.RecordingState) {
125
                if (camera.videoRecorder.recorderState == CameraRecorder.RecordingState) {
513
127
                    camera.videoRecorder.stop();
126
                    camera.videoRecorder.stop();
514
128
                }
127
                }
516
129
                camera.stop()
128
                camera.cameraState = Camera.LoadedState;
517
130
            }
129
            }
518
131
        }
130
        }
519
132
    }
131
    }
520
@@ -250,16 +249,16 @@
521
250
                axis.x: 0; axis.y: 1; axis.z: 0
249
                axis.x: 0; axis.y: 1; axis.z: 0
522
251
                angle: application.desktopMode ? 180 : 0
250
                angle: application.desktopMode ? 180 : 0
523
252
            }
251
            }
534
253
252
        }
535
254
            ViewFinderGeometry {
253
536
255
                id: viewFinderGeometry
254
        ViewFinderGeometry {
537
256
                anchors.centerIn: parent
255
            id: viewFinderGeometry
538
257
256
            anchors.centerIn: parent
539
258
                cameraResolution: camera.advanced.resolution
257
540
259
                viewFinderHeight: viewFinder.height
258
            cameraResolution: camera.viewfinder.resolution
541
260
                viewFinderWidth: viewFinder.width
259
            viewFinderHeight: viewFinder.height
542
261
                viewFinderOrientation: viewFinder.orientation
260
            viewFinderWidth: viewFinder.width
543
262
            }
261
            viewFinderOrientation: viewFinder.orientation
544
263
        }
262
        }
545
264
263
546
265
        Item {
264
        Item {
547
266
265
548
=== modified file 'tests/autopilot/camera_app/emulators/main_window.py'
549
--- tests/autopilot/camera_app/emulators/main_window.py	2015-11-20 15:01:02 +0000
550
+++ tests/autopilot/camera_app/emulators/main_window.py	2015-11-25 17:47:09 +0000
551
@@ -7,7 +7,7 @@
552
7
7
553
8
from camera_app.emulators.panel import Panel
8
from camera_app.emulators.panel import Panel
554
9
from autopilot.matchers import Eventually
9
from autopilot.matchers import Eventually
556
10
from testtools.matchers import Equals
10
from testtools.matchers import Equals, NotEquals
557
11
11
558
12
12
559
13
class MainWindow(object):
13
class MainWindow(object):
560
@@ -163,3 +163,22 @@
561
163
            tx, ty, (tx + view_switcher.width // 2), ty, rate=1)
163
            tx, ty, (tx + view_switcher.width // 2), ty, rate=1)
562
164
        viewfinder = self.get_viewfinder()
164
        viewfinder = self.get_viewfinder()
563
165
        testCase.assertThat(viewfinder.inView, Eventually(Equals(True)))
165
        testCase.assertThat(viewfinder.inView, Eventually(Equals(True)))
564
166
565
167
    def switch_cameras(self):
566
168
        # Swap cameras and wait for camera to settle
567
169
        shoot_button = self.get_exposure_button()
568
170
        swap_camera_button = self.get_swap_camera_button()
569
171
        self.app.pointing_device.move_to_object(swap_camera_button)
570
172
        self.app.pointing_device.click()
571
173
        shoot_button.enabled.wait_for(True)
572
174
573
175
    def switch_recording_mode(self):
574
176
        record_control = self.get_record_control()
575
177
576
178
        # Wait for the camera overlay to be loaded
577
179
        record_control.enabled.wait_for(True)
578
180
        record_control.width.wait_for(NotEquals(0))
579
181
        record_control.height.wait_for(NotEquals(0))
580
182
581
183
        self.app.pointing_device.move_to_object(record_control)
582
184
        self.app.pointing_device.click()
583
166
185
584
=== modified file 'tests/autopilot/camera_app/tests/test_capture.py'
585
--- tests/autopilot/camera_app/tests/test_capture.py	2015-10-05 13:14:12 +0000
586
+++ tests/autopilot/camera_app/tests/test_capture.py	2015-11-25 17:47:09 +0000
587
@@ -90,13 +90,11 @@
588
90
90
589
91
        """
91
        """
590
92
        # Get all the elements
92
        # Get all the elements
591
93
        record_control = self.main_window.get_record_control()
592
94
        stop_watch = self.main_window.get_stop_watch()
93
        stop_watch = self.main_window.get_stop_watch()
593
95
        exposure_button = self.main_window.get_exposure_button()
94
        exposure_button = self.main_window.get_exposure_button()
594
96
95
595
97
        # Click the record button to toggle photo/video mode
96
        # Click the record button to toggle photo/video mode
598
98
        self.pointing_device.move_to_object(record_control)
97
        self.main_window.switch_recording_mode()
597
99
        self.pointing_device.click()
599
100
98
600
101
        # Before recording the stop watch should read zero recording time
99
        # Before recording the stop watch should read zero recording time
601
102
        # and not be visible anyway.
100
        # and not be visible anyway.
602
@@ -137,8 +135,7 @@
603
137
        # Now stop the video and go back to picture mode and check if
135
        # Now stop the video and go back to picture mode and check if
604
138
        # everything resets itself to previous states
136
        # everything resets itself to previous states
605
139
        self.pointing_device.click()
137
        self.pointing_device.click()
608
140
        self.pointing_device.move_to_object(record_control)
138
        self.main_window.switch_recording_mode()
607
141
        self.pointing_device.click()
609
142
139
610
143
        self.assertThat(stop_watch.opacity, Eventually(Equals(0.0)))
140
        self.assertThat(stop_watch.opacity, Eventually(Equals(0.0)))
611
144
141
612
@@ -268,7 +265,7 @@
613
268
    """Test recording videos at a set resolution and switching cameras"""
265
    """Test recording videos at a set resolution and switching cameras"""
614
269
    def test_video_resolution_setting_switching_cameras(self):
266
    def test_video_resolution_setting_switching_cameras(self):
615
270
        # switch to video recording and empty video folder
267
        # switch to video recording and empty video folder
617
271
        self.switch_to_video_recording()
268
        self.main_window.switch_recording_mode()
618
272
        self.delete_all_videos()
269
        self.delete_all_videos()
619
273
270
620
274
        # select the first resolution for the current camera
271
        # select the first resolution for the current camera
621
@@ -277,14 +274,14 @@
622
277
        self.set_video_resolution(initial_resolution)
274
        self.set_video_resolution(initial_resolution)
623
278
275
624
279
        # switch cameras and select the last resolution for the current camera
276
        # switch cameras and select the last resolution for the current camera
626
280
        self.switch_cameras()
277
        self.main_window.switch_cameras()
627
281
        resolutions = self.get_available_video_resolutions()
278
        resolutions = self.get_available_video_resolutions()
628
282
        expected_resolution = resolutions[-1]
279
        expected_resolution = resolutions[-1]
629
283
        self.assertThat(expected_resolution, NotEquals(initial_resolution))
280
        self.assertThat(expected_resolution, NotEquals(initial_resolution))
630
284
        self.set_video_resolution(expected_resolution)
281
        self.set_video_resolution(expected_resolution)
631
285
282
632
286
        # switch back to the initial camera and record a video
283
        # switch back to the initial camera and record a video
634
287
        self.switch_cameras()
284
        self.main_window.switch_cameras()
635
288
        self.record_video(2)
285
        self.record_video(2)
636
289
        video_file = self.get_first_video()
286
        video_file = self.get_first_video()
637
290
        height = self.read_video_height(video_file)
287
        height = self.read_video_height(video_file)
638
@@ -292,17 +289,9 @@
639
292
            expected_resolution)
289
            expected_resolution)
640
293
        self.assertThat(height, Equals(expected_height))
290
        self.assertThat(height, Equals(expected_height))
641
294
291
642
295
    def switch_cameras(self):
643
296
        # Swap cameras and wait for camera to settle
644
297
        shoot_button = self.main_window.get_exposure_button()
645
298
        swap_camera_button = self.main_window.get_swap_camera_button()
646
299
        self.pointing_device.move_to_object(swap_camera_button)
647
300
        self.pointing_device.click()
648
301
        self.assertThat(shoot_button.enabled, Eventually(Equals(True)))
649
302
650
303
    """Test recording videos at various resolutions"""
292
    """Test recording videos at various resolutions"""
651
304
    def test_video_resolution_setting(self):
293
    def test_video_resolution_setting(self):
653
305
        self.switch_to_video_recording()
294
        self.main_window.switch_recording_mode()
654
306
        resolutions = self.get_available_video_resolutions()
295
        resolutions = self.get_available_video_resolutions()
655
307
296
656
308
        for resolution_label in resolutions:
297
        for resolution_label in resolutions:
657
@@ -316,16 +305,6 @@
658
316
            self.assertThat(height, Equals(expected_height))
305
            self.assertThat(height, Equals(expected_height))
659
317
            self.dismiss_first_photo_hint()
306
            self.dismiss_first_photo_hint()
660
318
307
661
319
    def switch_to_video_recording(self):
662
320
        record_control = self.main_window.get_record_control()
663
321
        # Wait for the camera overlay to be loaded
664
322
        self.assertThat(record_control.enabled, Eventually(Equals(True)))
665
323
        self.assertThat(record_control.width, Eventually(NotEquals(0)))
666
324
        self.assertThat(record_control.height, Eventually(NotEquals(0)))
667
325
668
326
        self.pointing_device.move_to_object(record_control)
669
327
        self.pointing_device.click()
670
328
671
329
    def get_available_video_resolutions(self):
308
    def get_available_video_resolutions(self):
672
330
        # open bottom edge
309
        # open bottom edge
673
331
        bottom_edge = self.main_window.get_bottom_edge()
310
        bottom_edge = self.main_window.get_bottom_edge()
674
332
311
675
=== modified file 'tests/autopilot/camera_app/tests/test_zoom.py'
676
--- tests/autopilot/camera_app/tests/test_zoom.py	2015-04-29 15:56:44 +0000
677
+++ tests/autopilot/camera_app/tests/test_zoom.py	2015-11-25 17:47:09 +0000
678
@@ -68,3 +68,50 @@
679
68
68
680
69
        self.pointing_device.drag(tx, ty, (tx - zoom_control.width), ty)
69
        self.pointing_device.drag(tx, ty, (tx - zoom_control.width), ty)
681
70
        self.assertThat(zoom_control.value, Eventually(Equals(1.0)))
70
        self.assertThat(zoom_control.value, Eventually(Equals(1.0)))
682
71
683
72
    """Tests zoom is reset to minimum on camera switch"""
684
73
    def test_zoom_reset_on_camera_change(self):
685
74
        zoom_control = self.main_window.get_zoom_control()
686
75
        zoom_slider = self.main_window.get_zoom_slider()
687
76
688
77
        self.activate_zoom()
689
78
        x, y, w, h = zoom_slider.globalRect
690
79
        tx = x + (w // 2)
691
80
        ty = y + (h // 2)
692
81
        self.pointing_device.drag(tx, ty, (tx + zoom_control.width), ty)
693
82
        self.assertThat(
694
83
            zoom_control.value, Eventually(Equals(zoom_control.maximumValue)))
695
84
696
85
        self.main_window.switch_cameras()
697
86
        self.assertThat(
698
87
            zoom_control.value, Eventually(Equals(zoom_control.minimumValue)))
699
88
700
89
        self.activate_zoom()
701
90
        self.pointing_device.drag(tx, ty, (tx + zoom_control.width), ty)
702
91
        self.assertThat(
703
92
            zoom_control.value, Eventually(Equals(zoom_control.maximumValue)))
704
93
705
94
        self.main_window.switch_cameras()
706
95
        self.assertThat(
707
96
            zoom_control.value, Eventually(Equals(zoom_control.minimumValue)))
708
97
709
98
    """Tests zoom is reset to minimum on recording mode switch"""
710
99
    def test_zoom_reset_on_recording_mode_change(self):
711
100
        zoom_control = self.main_window.get_zoom_control()
712
101
        zoom_slider = self.main_window.get_zoom_slider()
713
102
714
103
        self.activate_zoom()
715
104
        x, y, w, h = zoom_slider.globalRect
716
105
        tx = x + (w // 2)
717
106
        ty = y + (h // 2)
718
107
        self.pointing_device.drag(tx, ty, (tx + zoom_control.width), ty)
719
108
        self.assertThat(
720
109
            zoom_control.value, Eventually(Equals(zoom_control.maximumValue)))
721
110
722
111
        self.main_window.switch_recording_mode()
723
112
        self.assertThat(
724
113
            zoom_control.value, Eventually(Equals(zoom_control.minimumValue)))
725
114
726
115
        # Ideally we should test the same thing when switching back to photo
727
116
        # mode, however due to http://pad.lv/1191088 zooming when recording
728
117
        # video is disabled, so adding that test is pointless until fixed.
Reviewer	Review Type	Date Requested	Status
PS Jenkins bot	continuous-integration		Needs Fixing on 2015-11-25
Bill Filler (community)		2015-10-14	Needs Fixing on 2015-11-19
Review via email: mp+274402@code.launchpad.net