376c593 · unity8 · git.iko.soy

git.iko.soy/unity8

Refactor to use signals

commit376c593a6f1b9af089dd2e06519c717472128576 authorMichał Sawicz <michal.sawicz@canonical.com> dateMon 16 Feb 2015, 23:21 (12 years ago) parent7888692

3 files changed+95−64

compare with xenial

unifiedsplit

qml/Components/PhysicalKeysMapper.qml+33−23 qml/Shell.qml+5−11 tests/qmltests/Components/tst_PhysicalKeysMapper.qml+57−30

qml/Components/PhysicalKeysMapper.qml+33−23

@@ -35,17 +35,17 @@ import Powerd 0.1

3535Item {

3636 id: root

3737

38− signal powerKeyLongPress();

39−

40− property bool screenshotPressed: d.volumeUpKeyPressed && d.volumeDownKeyPressed

41− property bool volumeDownPressed: d.volumeDownKeyPressed && !d.volumeUpKeyPressed

42− property bool volumeUpPressed: d.volumeUpKeyPressed && !d.volumeDownKeyPressed

38+ signal powerKeyLongPress;

39+ signal volumeDownTrigger;

40+ signal volumeUpTrigger;

41+ signal screenshotTrigger;

4342

4443 QtObject {

4544 id: d

4645

4746 property bool volumeDownKeyPressed: false

4847 property bool volumeUpKeyPressed: false

48+ property bool ignoreVolumeEvents: false

4949 }

5050

5151 Timer {

@@ -57,10 +57,9 @@ Item {

5757

5858

5959 function onKeyPressed(event) {

60− var eventAccepted = false;

61−

6260 /* Determine what key was pressed */

63− if (event.key == Qt.Key_PowerDown || event.key == Qt.Key_PowerOff) {

61+ if ((event.key == Qt.Key_PowerDown || event.key == Qt.Key_PowerOff)

62+ && !event.isAutoRepeat) {

6463

6564 // FIXME: We only consider power key presses if the screen is

6665 // on because of bugs 1410830/1409003. The theory is that when

@@ -71,34 +70,45 @@ Item {

7170 // initiate any dialogs when the screen is off.

7271 // This also prevents taking screenshots when the screen is off.

7372 if (Powerd.status === Powerd.On) {

74− if (!event.isAutoRepeat) {

75− powerKeyLongPressTimer.restart();

76− }

77− eventAccepted = true;

73+ powerKeyLongPressTimer.restart();

74+ event.accepted = true;

7875 }

79− } else if (event.key == Qt.Key_MediaTogglePlayPause || event.key == Qt.Key_MediaPlay) {

80− eventAccepted = callManager.handleMediaKey(false);

76+ } else if ((event.key == Qt.Key_MediaTogglePlayPause || event.key == Qt.Key_MediaPlay)

77+ && !event.isAutoRepeat) {

78+ event.accepted = callManager.handleMediaKey(false);

8179 } else if (event.key == Qt.Key_VolumeDown) {

82− d.volumeDownKeyPressed = true;

80+ if (event.isAutoRepeat && !d.ignoreVolumeEvents) root.volumeDownTrigger();

81+ else if (!event.isAutoRepeat) {

82+ if (d.volumeUpKeyPressed) {

83+ root.screenshotTrigger();

84+ d.ignoreVolumeEvents = true;

85+ }

86+ d.volumeDownKeyPressed = true;

87+ }

8388 } else if (event.key == Qt.Key_VolumeUp) {

84− d.volumeUpKeyPressed = true;

89+ if (event.isAutoRepeat && !d.ignoreVolumeEvents) root.volumeUpTrigger();

90+ else if (!event.isAutoRepeat) {

91+ if (d.volumeDownKeyPressed) {

92+ root.screenshotTrigger();

93+ d.ignoreVolumeEvents = true;

94+ }

95+ d.volumeUpKeyPressed = true;

96+ }

8597 }

86−

87− return eventAccepted;

8898 }

8999

90100 function onKeyReleased(event) {

91− var eventAccepted = false;

92−

93101 if (event.key == Qt.Key_PowerDown || event.key == Qt.Key_PowerOff) {

94102 powerKeyLongPressTimer.stop();

95− eventAccepted = true;

103+ event.accepted = true;

96104 } else if (event.key == Qt.Key_VolumeDown) {

105+ if (!d.ignoreVolumeEvents) root.volumeDownTrigger();

97106 d.volumeDownKeyPressed = false;

107+ if (!d.volumeUpKeyPressed) d.ignoreVolumeEvents = false;

98108 } else if (event.key == Qt.Key_VolumeUp) {

109+ if (!d.ignoreVolumeEvents) root.volumeUpTrigger();

99110 d.volumeUpKeyPressed = false;

111+ if (!d.volumeDownKeyPressed) d.ignoreVolumeEvents = false;

100112 }

101−

102− return eventAccepted;

103113 }

104114}

qml/Shell.qml+5−11

@@ -164,10 +164,9 @@ Item {

164164 id: physicalKeysMapper

165165

166166 onPowerKeyLongPress: dialogs.showPowerDialog()

167− onVolumeDownPressedChanged: if (volumeDownPressed) { volumeControl.volumeDown(); }

168− onVolumeUpPressedChanged: if (volumeUpPressed) { volumeControl.volumeUp(); }

169− onScreenshotPressedChanged: if (screenshotPressed) { screenGrabber.capture(); }

170−

167+ onVolumeDownTriggered: volumeControl.volumeDown();

168+ onVolumeUpTriggered: volumeControl.volumeUp();

169+ onScreenshotTriggered: screenGrabber.capture();

171170 }

172171

173172 ScreenGrabber {

@@ -183,13 +182,8 @@ Item {

183182 }

184183

185184 WindowKeysFilter {

186− Keys.onPressed: {

187− event.accepted = physicalKeysMapper.onKeyPressed(event);

188− }

189−

190− Keys.onReleased: {

191− event.accepted = physicalKeysMapper.onKeyReleased(event);

192− }

185+ Keys.onPressed: physicalKeysMapper.onKeyPressed(event);

186+ Keys.onReleased: physicalKeysMapper.onKeyReleased(event);

193187 }

194188

195189 Item {

tests/qmltests/Components/tst_PhysicalKeysMapper.qml+57−30

@@ -21,61 +21,88 @@ import "../../../qml/Components"

2121TestCase {

2222 name: "PhysicalKeysMapper"

2323

24− PhysicalKeysMapper {

25− id: physicalKeysMapper

24+ Loader {

25+ id: loader

26+ active: false

27+ sourceComponent: PhysicalKeysMapper { }

2628 }

2729

2830 SignalSpy {

2931 id: powerSpy

30− target: physicalKeysMapper

32+ target: loader.item

3133 signalName: "powerKeyLongPress"

3234 }

3335

34− function cleanup() {

35− physicalKeysMapper.onKeyReleased({ key: Qt.Key_PowerDown });

36− physicalKeysMapper.onKeyReleased({ key: Qt.Key_VolumeDown });

37− physicalKeysMapper.onKeyReleased({ key: Qt.Key_VolumeUp });

36+ SignalSpy {

37+ id: volumeDownSpy

38+ target: loader.item

39+ signalName: "volumeDownTrigger"

40+ }

41+

42+ SignalSpy {

43+ id: volumeUpSpy

44+ target: loader.item

45+ signalName: "volumeUpTrigger"

46+ }

47+

48+ SignalSpy {

49+ id: screenshotSpy

50+ target: loader.item

51+ signalName: "screenshotTrigger"

52+ }

53+

54+ function init() {

55+ loader.active = true;

56+ tryCompare(loader.status == Loader.Ready);

57+ }

3858

59+ function cleanup() {

60+ loader.active = false;

3961 powerSpy.clear();

62+ volumeDownSpy.clear();

63+ volumeUpSpy.clear();

64+ screenshotSpy.clear();

4065 }

4166

4267 function test_LongPressPowerButton() {

43− physicalKeysMapper.onKeyPressed({ key: Qt.Key_PowerDown });

68+ loader.item.onKeyPressed({ key: Qt.Key_PowerDown });

4469

4570 expectFailContinue("", "Power signal should not be emitted within a second");

4671 powerSpy.wait(1000);

4772 powerSpy.clear();

4873

49− physicalKeysMapper.onKeyPressed({ key: Qt.Key_PowerDown, isAutoRepeat: true });

74+ loader.item.onKeyPressed({ key: Qt.Key_PowerDown, isAutoRepeat: true });

5075 powerSpy.wait(1500);

5176 }

5277

53− function test_ScreenshotButtons() {

54− /* Behavior when VolumeUp is pressed 1st */

55− physicalKeysMapper.onKeyPressed({ key: Qt.Key_VolumeUp });

56− physicalKeysMapper.onKeyPressed({ key: Qt.Key_VolumeDown });

57− compare(physicalKeysMapper.screenshotPressed, true);

58− compare(physicalKeysMapper.volumeDownPressed, false);

59−

60− physicalKeysMapper.onKeyReleased({ key: Qt.Key_VolumeUp });

61− physicalKeysMapper.onKeyReleased({ key: Qt.Key_VolumeDown });

62−

63− /* Behavior when VolumeDown is pressed 1st */

64− physicalKeysMapper.onKeyPressed({ key: Qt.Key_VolumeDown });

65− compare(physicalKeysMapper.volumeDownPressed, true);

66− physicalKeysMapper.onKeyPressed({ key: Qt.Key_VolumeUp });

67− compare(physicalKeysMapper.screenshotPressed, true);

78+ function test_ScreenshotButtons_data() {

79+ return [

80+ { tag: "UpFirst", first: Qt.Key_VolumeUp, second: Qt.Key_VolumeDown },

81+ { tag: "DownFirst", first: Qt.Key_VolumeDown, second: Qt.Key_VolumeUp },

82+ ];

83+ }

84+

85+ function test_ScreenshotButtons(data) {

86+ loader.item.onKeyPressed({ key: data.first });

87+ loader.item.onKeyPressed({ key: data.second });

88+ screenshotSpy.wait();

89+ loader.item.onKeyReleased({ key: data.first });

90+ loader.item.onKeyReleased({ key: data.second });

91+ expectFailContinue("", "VolumeUp signal should not fire");

92+ volumeUpSpy.wait(100);

93+ expectFailContinue("", "VolumeDown signal should not fire");

94+ volumeDownSpy.wait(100);

6895 }

6996

7097 function test_VolumeDownButton() {

71− compare(physicalKeysMapper.volumeDownPressed, false);

72− physicalKeysMapper.onKeyPressed({ key: Qt.Key_VolumeDown });

73− compare(physicalKeysMapper.volumeDownPressed, true);

98+ loader.item.onKeyPressed({ key: Qt.Key_VolumeDown });

99+ loader.item.onKeyReleased({ key: Qt.Key_VolumeDown });

100+ volumeDownSpy.wait();

74101 }

75102

76103 function test_VolumeUpButton() {

77− compare(physicalKeysMapper.volumeUpPressed, false);

78− physicalKeysMapper.onKeyPressed({ key: Qt.Key_VolumeUp });

79− compare(physicalKeysMapper.volumeUpPressed, true);

104+ loader.item.onKeyPressed({ key: Qt.Key_VolumeUp });

105+ loader.item.onKeyReleased({ key: Qt.Key_VolumeUp });

106+ volumeUpSpy.wait();

80107 }

81108}