527a6ca · unity8 · git.iko.soy

21Item {

22 id: applicationManager

23

24− property var mainStageApplications: ApplicationManager.mainStageApplications

24+ property var mainStageApplications: mainStageModel

25− property var sideStageApplications: ApplicationManager.sideStageApplications

25+ property var sideStageApplications: sideStageModel

26− property var mainStageFocusedApplication: mainStageModel

26+ property var mainStageFocusedApplication: null

27− property var sideStageFocusedApplication: sideStageModel

27+ property var sideStageFocusedApplication: null

28 property bool sideStageEnabled: true

29 signal focusRequested(string desktopFile)

30 property bool keyboardVisible: ApplicationManager.keyboardVisible

40 filterRegExp: RegExp(ApplicationInfo.MainStage)

41

42 onCountChanged: { print("MODEL Main:", count, ApplicationManager.RoleStage, ApplicationManager.RoleFocused)

43− mainStageFocusedApplication = mainStageModel.findFirst(ApplicationManager.RoleFocused, true);

43+ mainStageFocusedApplication = ApplicationManager.get(mainStageModel.findFirst(ApplicationManager.RoleFocused, true));

44 print("MS", mainStageFocusedApplication)

45 }

46+ onLayoutChanged: print("LAYOUT")

47+ onDataChanged: print("DATA")

46 }

48 }

47

49

48 SortFilterProxyModel {

50 SortFilterProxyModel {

53 filterRegExp: RegExp(ApplicationInfo.SideStage)

55 filterRegExp: RegExp(ApplicationInfo.SideStage)

54

56

55 onDataChanged: { print("MODEL Side", count)

57 onDataChanged: { print("MODEL Side", count)

56− sideStageFocusedApplication = sideStageModel.findFirst(ApplicationManager.RoleFocused, true);

58+ sideStageFocusedApplication = ApplicationManager.get(sideStageModel.findFirst(ApplicationManager.RoleFocused, true));

57 print("SS", sideStageFocusedApplication)

59 print("SS", sideStageFocusedApplication)

58 }

60 }

59 }

61 }

60

62

61 function activateApplication(desktopFile, argument) {

63 function activateApplication(desktopFile, argument) {

62− var application;

64+ var appId;

63− application = getApplicationFromDesktopFile(desktopFile, ApplicationInfo.MainStage);

65+

64− if (application == null) {

66+ // HACK: might be called with appId, but mostly with desktopFile

65− application = getApplicationFromDesktopFile(desktopFile, ApplicationInfo.SideStage);

67+ if (desktopFile.indexOf(".desktop") = -1) {

68+ appId = desktopFileToAppId(desktopFile);

69+ } else {

70+ appId = desktopFile;

66 }

71 }

72+

73+ var application = ApplicationManager.findApplication(appId);

67− if (application != null) {

74+ if (application !== null) {

68 return application;

75 return application;

69 }

76 }

70

77

71 var execFlags = sideStageEnabled ? ApplicationManager.NoFlag : ApplicationManager.ForceMainStage;

78 var execFlags = sideStageEnabled ? ApplicationManager.NoFlag : ApplicationManager.ForceMainStage;

72

79

73 if (argument) {

80 if (argument) {

74− return ApplicationManager.startProcess(desktopFile, execFlags, [argument]);

81+ return ApplicationManager.startApplication(appId, execFlags, [argument]);

75 } else {

82 } else {

76− return ApplicationManager.startProcess(desktopFile, execFlags);

83+ return ApplicationManager.startApplication(appId, execFlags);

77 }

84 }

78 }

85 }

79

86

80 function stopProcess(application) {

87 function stopProcess(application) {

88+ var appId;

89+

90+ // HACK: might be called with appId, or else with Application object

91+ if (typeof application == "string") {

92+ appId = desktopFileToAppId(application.desktopFile);

93+ } else {

94+ appId = application;

95+ }

96+

81− ApplicationManager.stopProcess(application)

97+ ApplicationManager.stopProcess(appId);

82 }

98 }

83

99

84 function focusApplication(application) {

100 function focusApplication(application) {

86 return;

102 return;

87 }

103 }

88

104

89− ApplicationManager.focusApplication(application.handle);

105+ ApplicationManager.focusApplication(application.appId);

90 }

106 }

91

107

92 function unfocusCurrentApplication() {

108 function unfocusCurrentApplication() {

93− ApplicationManager.unfocusCurrentApplication(ApplicationInfo.MainStage);

109+ ApplicationManager.unfocusCurrentApplication();

94 }

110 }

95

111

96− function moveRunningApplicationStackPosition(from, to, stage) {

112+ function moveRunningApplicationStackPosition(from, to, stage) { //FIXME: stage unused!

97− var applications;

98− if (stage == ApplicationInfo.SideStage) {

99− applications = ApplicationManager.sideStageApplications;

100− } else {

101− applications = ApplicationManager.mainStageApplications;

102− }

103− // FIXME: applications.move(0, 0) crashes

104− if (from !== to && from >= 0 && to >= 0) applications.move(from, to);

113+ if (from !== to && from >= 0 && to >= 0) ApplicationManager.move(from, to);

105 }

114 }

106

115

107 function getApplicationFromDesktopFile(desktopFile, stage) {

116 function getApplicationFromDesktopFile(desktopFile, stage) {

108 var foundSideStageApp, foundMainStageApp;

117 var foundSideStageApp, foundMainStageApp;

118+ var appId = desktopFileToAppId(desktopFile);

109

119

110− foundMainStageApp = __find(desktopFile, ApplicationManager.mainStageApplications)

120+ for (var i = 0, len = ApplicationManager.count; i < len; i++ ) {

111− if (stage == ApplicationInfo.MainStage) {

121+ var app = ApplicationManager.get(i);

112− return foundMainStageApp;

113− }

114− foundSideStageApp = __find(desktopFile, ApplicationManager.sideStageApplications)

115− if (stage == ApplicationInfo.SideStage) {

116− return foundSideStageApp;

117− }

118−

119− // if stage not specified, return whichever app running on either stage

120− return (foundMainStageApp) ? foundMainStageApp : foundSideStageApp;

121−

122

123− function __find(desktopFile, applications) {

123+ // if stage not specified, return whichever app running on either stage

124− for (var i = 0; i < applications.count; i++ ) {

124+ if (app.appId == appId && (stage == undefined || app.stage == stage)) {

125− var application = applications.get(i);

126− if (application.desktopFile == desktopFile) {

127− return application;

125+ return app;

128− }

129 }

126 }

130− return null;

131 }

127 }

132 }

128 }

133

129

134 function desktopFileToAppId(desktopFile) {

130 function desktopFileToAppId(desktopFile) {

135− var right = desktopFile.lastIndexOf(".desktop")

131+ var right = desktopFile.lastIndexOf(".desktop");

136− var left = desktopFile.lastIndexOf("/")

132+ var left = desktopFile.lastIndexOf("/");

137 if (left == -1 || right == -1 || left == right) {

133 if (left == -1 || right == -1 || left == right) {

138− console.log("ApplicationManagerWrapper: unable to extract appId from " + desktopFile)

134+ console.log("ApplicationManagerWrapper: unable to extract appId from '" + desktopFile + "'");

139 return "";

135 return "";

140 }

136 }

141− return desktopFile.substring(left+1, right)

137+ return desktopFile.substring(left+1, right);

142 }

138 }

143

139

144 function appIdToDesktopFile(desktopFile) {

140 function appIdToDesktopFile(desktopFile) {