1
|
|
|
import logging |
2
|
|
|
import os |
3
|
|
|
import string |
4
|
|
|
|
5
|
|
|
from PyQt5 import QtCore |
6
|
|
|
|
7
|
|
|
from qtodotxt2.lib import tasklib |
8
|
|
|
from qtodotxt2.lib.file import File |
9
|
|
|
from qtodotxt2.filters_controller import FiltersController |
10
|
|
|
|
11
|
|
|
logger = logging.getLogger(__name__) |
12
|
|
|
|
13
|
|
|
|
14
|
|
|
class MainController(QtCore.QObject): |
15
|
|
|
|
16
|
|
|
error = QtCore.pyqtSignal(str, arguments=["msg"]) |
17
|
|
|
fileExternallyModified = QtCore.pyqtSignal() |
18
|
|
|
|
19
|
|
|
def __init__(self, args): |
20
|
|
|
super(MainController, self).__init__() |
21
|
|
|
self._args = args |
22
|
|
|
self._filteredTasks = [] |
23
|
|
|
self._sortingMode = "default" |
24
|
|
|
# use object variable for setting only used in this class |
25
|
|
|
# others are accessed through QSettings |
26
|
|
|
self._settings = QtCore.QSettings() |
27
|
|
|
self._file = File() |
28
|
|
|
self._file.fileExternallyModified.connect(self.fileExternallyModified) |
29
|
|
|
self._file.fileModified.connect(self._fileModified) |
30
|
|
|
self.filtersController = FiltersController() |
31
|
|
|
self._title = "QTodoTxt" |
32
|
|
|
self._recentFiles = self._settings.value("recent_files", []) |
33
|
|
|
self._updateCompletionStrings() |
34
|
|
|
self._forced = None |
35
|
|
|
|
36
|
|
|
def showError(self, msg): |
37
|
|
|
logger.debug("ERROR: %s", msg) |
38
|
|
|
self.error.emit(msg) |
39
|
|
|
|
40
|
|
|
completionChanged = QtCore.pyqtSignal() |
41
|
|
|
|
42
|
|
|
@QtCore.pyqtProperty('QStringList', notify=completionChanged) |
43
|
|
|
def completionStrings(self): |
44
|
|
|
return self._completionStrings |
45
|
|
|
|
46
|
|
|
def _updateCompletionStrings(self): |
47
|
|
|
contexts = ['@' + name for name in self._file.getAllContexts()] |
48
|
|
|
projects = ['+' + name for name in self._file.getAllProjects()] |
49
|
|
|
lowest_priority = self._settings.value("lowest_priority", "D") |
50
|
|
|
idx = string.ascii_uppercase.index(lowest_priority) + 1 |
51
|
|
|
priorities = ['(' + val + ')' for val in string.ascii_uppercase[:idx]] |
52
|
|
|
self._completionStrings = contexts + projects + priorities + ['due:'] |
53
|
|
|
self.completionChanged.emit() |
54
|
|
|
|
55
|
|
|
@QtCore.pyqtSlot('QModelIndexList') |
56
|
|
|
def filterByIndexes(self, idxs): |
57
|
|
|
self.filtersController.setFiltersByIndexes(idxs) |
58
|
|
|
self.applyFilters() |
59
|
|
|
|
60
|
|
|
@QtCore.pyqtSlot('QString', 'int', result='int') |
61
|
|
|
def newTask(self, text='', after=None): |
62
|
|
|
task = tasklib.Task(text) |
63
|
|
|
if bool(self._settings.value("Preferences/add_creation_date", False, type=bool)): |
64
|
|
|
task.addCreationDate() |
65
|
|
|
if after is None: |
66
|
|
|
after = len(self._filteredTasks) - 1 |
67
|
|
|
#self._file.addTask(task) |
68
|
|
|
self._filteredTasks.insert(after + 1, task) # force the new task to be visible |
69
|
|
|
self._file.tasks.append(task) |
70
|
|
|
|
71
|
|
|
self._file.connectTask(task) #Ensure task will be added |
72
|
|
|
self.filteredTasksChanged.emit() |
73
|
|
|
return after + 1 |
74
|
|
|
|
75
|
|
|
@QtCore.pyqtSlot('QVariant') |
76
|
|
|
def deleteTask(self, task): |
77
|
|
|
if not isinstance(task, tasklib.Task): |
78
|
|
|
# if task is not a task assume it is an int |
79
|
|
|
task = self._filteredTasks[task] |
80
|
|
|
self._file.deleteTask(task) |
81
|
|
|
|
82
|
|
|
@property |
83
|
|
|
def allTasks(self): |
84
|
|
|
return self._file.tasks |
85
|
|
|
|
86
|
|
|
@allTasks.setter |
87
|
|
|
def allTasks(self, tasks): |
88
|
|
|
self._file.tasks = tasks |
89
|
|
|
|
90
|
|
|
filteredTasksChanged = QtCore.pyqtSignal() |
91
|
|
|
|
92
|
|
|
@QtCore.pyqtProperty('QVariant', notify=filteredTasksChanged) |
93
|
|
|
def filteredTasks(self): |
94
|
|
|
return self._filteredTasks |
95
|
|
|
|
96
|
|
|
showFutureChanged = QtCore.pyqtSignal('bool') |
97
|
|
|
|
98
|
|
|
@QtCore.pyqtProperty('bool', notify=showFutureChanged) |
99
|
|
|
def showFuture(self): |
100
|
|
|
return self.filtersController.showFuture |
101
|
|
|
|
102
|
|
|
@showFuture.setter |
103
|
|
|
def showFuture(self, val): |
104
|
|
|
self.filtersController.showFuture = val |
105
|
|
|
self.showFutureChanged.emit(val) |
106
|
|
|
self.applyFilters() |
107
|
|
|
|
108
|
|
|
sortingModeChanged = QtCore.pyqtSignal(str) |
109
|
|
|
|
110
|
|
|
@QtCore.pyqtProperty(str, notify=showFutureChanged) |
111
|
|
|
def sortingMode(self): |
112
|
|
|
return self._sortingMode |
113
|
|
|
|
114
|
|
|
@sortingMode.setter |
115
|
|
|
def sortingMode(self, val): |
116
|
|
|
self._sortingMode = val |
117
|
|
|
self.sortingModeChanged.emit(val) |
118
|
|
|
self.applyFilters() |
119
|
|
|
|
120
|
|
|
searchTextChanged = QtCore.pyqtSignal(str) |
121
|
|
|
|
122
|
|
|
@QtCore.pyqtProperty('QString', notify=searchTextChanged) |
123
|
|
|
def searchText(self): |
124
|
|
|
return self.filtersController.searchText |
125
|
|
|
|
126
|
|
|
@searchText.setter |
127
|
|
|
def searchText(self, txt): |
128
|
|
|
self.filtersController.searchText = txt |
129
|
|
|
self.applyFilters() |
130
|
|
|
self.searchTextChanged.emit(txt) |
131
|
|
|
|
132
|
|
|
showCompletedChanged = QtCore.pyqtSignal('bool') |
133
|
|
|
|
134
|
|
|
@QtCore.pyqtProperty('bool', notify=showCompletedChanged) |
135
|
|
|
def showCompleted(self): |
136
|
|
|
return self.filtersController.showCompleted |
137
|
|
|
|
138
|
|
|
@showCompleted.setter |
139
|
|
|
def showCompleted(self, val): |
140
|
|
|
self.filtersController.showCompleted = val |
141
|
|
|
self.showCompletedChanged.emit(val) |
142
|
|
|
self.applyFilters() |
143
|
|
|
|
144
|
|
|
def auto_save(self): |
145
|
|
|
if bool(self._settings.value("Preferences/auto_save", True, type=bool)): |
146
|
|
|
self.save() |
147
|
|
|
|
148
|
|
|
def start(self): |
149
|
|
|
if self._args.file: |
150
|
|
|
filename = self._args.file |
151
|
|
|
else: |
152
|
|
|
filename = self._settings.value("last_open_file") |
153
|
|
|
|
154
|
|
|
if filename: |
155
|
|
|
try: |
156
|
|
|
self.open(filename) |
157
|
|
|
except OSError as ex: |
158
|
|
|
self.showError(str(ex)) |
159
|
|
|
|
160
|
|
|
self.applyFilters() |
161
|
|
|
self._updateTitle() |
162
|
|
|
|
163
|
|
|
filtersUpdated = QtCore.pyqtSignal() |
164
|
|
|
|
165
|
|
|
@QtCore.pyqtProperty('QVariant', notify=filtersUpdated) |
166
|
|
|
def filtersModel(self): |
167
|
|
|
return self.filtersController.model |
168
|
|
|
|
169
|
|
|
def _updateFilterTree(self): |
170
|
|
|
self.filtersController.updateFiltersModel(self._file) |
171
|
|
|
self.filtersUpdated.emit() |
172
|
|
|
|
173
|
|
|
def applyFilters(self, filters=None): |
174
|
|
|
if filters is not None: |
175
|
|
|
self.filtersController.setFilters(filters) |
176
|
|
|
tasks = self.filtersController.filter(self._file.tasks) |
177
|
|
|
tasks = getattr(tasklib.TaskSorter, self._sortingMode)(tasks) |
178
|
|
|
self._filteredTasks = tasks |
179
|
|
|
self.filteredTasksChanged.emit() |
180
|
|
|
|
181
|
|
|
@QtCore.pyqtSlot() |
182
|
|
|
def archiveCompletedTasks(self): |
183
|
|
|
done = [task for task in self._file.tasks if task.is_complete] |
184
|
|
|
for task in done: |
185
|
|
|
self._file.saveDoneTask(task) |
186
|
|
|
self._file.deleteTasl(task) |
187
|
|
|
self.applyFilters() |
188
|
|
|
self.auto_save() |
189
|
|
|
|
190
|
|
|
modifiedChanged = QtCore.pyqtSignal(bool) |
191
|
|
|
|
192
|
|
|
@QtCore.pyqtProperty('bool', notify=modifiedChanged) |
193
|
|
|
def modified(self): |
194
|
|
|
return self._file.modified |
195
|
|
|
|
196
|
|
|
def _fileModified(self, val=True): |
197
|
|
|
if val: |
198
|
|
|
self.auto_save() |
199
|
|
|
self.applyFilters() |
200
|
|
|
self._updateCompletionStrings() |
201
|
|
|
self._updateFilterTree() |
202
|
|
|
self._updateTitle() |
203
|
|
|
self.modifiedChanged.emit(val) |
204
|
|
|
|
205
|
|
|
@QtCore.pyqtSlot("QUrl") |
206
|
|
|
@QtCore.pyqtSlot() |
207
|
|
|
def save(self, path=None): |
208
|
|
|
if not path: |
209
|
|
|
path = self._file.filename |
210
|
|
|
elif isinstance(path, QtCore.QUrl): |
211
|
|
|
path = path.toLocalFile() |
212
|
|
|
self._file.filename = path |
213
|
|
|
|
214
|
|
|
logger.debug('MainController, saving file: %s.', path) |
215
|
|
|
try: |
216
|
|
|
self._file.save(path) |
217
|
|
|
except OSError as ex: |
218
|
|
|
logger.exception("Error saving file %s", path) |
219
|
|
|
self.showError(ex) |
220
|
|
|
return |
221
|
|
|
self._settings.setValue("last_open_file", path) |
222
|
|
|
self._settings.sync() |
223
|
|
|
|
224
|
|
|
def _updateTitle(self): |
225
|
|
|
title = 'QTodoTxt - ' |
226
|
|
|
if self._file.filename: |
227
|
|
|
filename = os.path.basename(self._file.filename) |
228
|
|
|
title += filename |
229
|
|
|
else: |
230
|
|
|
title += 'Untitled' |
231
|
|
|
if self._file.modified: |
232
|
|
|
title += ' (*)' |
233
|
|
|
self._title = title |
234
|
|
|
self.titleChanged.emit(self._title) |
235
|
|
|
|
236
|
|
|
titleChanged = QtCore.pyqtSignal(str) |
237
|
|
|
|
238
|
|
|
@QtCore.pyqtProperty('QString', notify=titleChanged) |
239
|
|
|
def title(self): |
240
|
|
|
return self._title |
241
|
|
|
|
242
|
|
|
@QtCore.pyqtSlot(result='bool') |
243
|
|
|
def canExit(self): |
244
|
|
|
self.auto_save() |
245
|
|
|
return not self._file.modified |
246
|
|
|
|
247
|
|
|
def new(self): |
248
|
|
|
if self.canExit(): |
249
|
|
|
self._file = File() |
250
|
|
|
self._loadFileToUI() |
251
|
|
|
|
252
|
|
|
@QtCore.pyqtSlot() |
253
|
|
|
def reload(self): |
254
|
|
|
self.open(self._file.filename) |
255
|
|
|
|
256
|
|
|
@QtCore.pyqtSlot('QUrl') |
257
|
|
|
@QtCore.pyqtSlot('QString') |
258
|
|
|
def open(self, filename): |
259
|
|
|
if isinstance(filename, QtCore.QUrl): |
260
|
|
|
filename = filename.toLocalFile() |
261
|
|
|
logger.debug('MainController.open called with filename="%s"', filename) |
262
|
|
|
try: |
263
|
|
|
self._file.load(filename) |
264
|
|
|
except Exception as ex: |
265
|
|
|
self.showError(self.tr("Error opening file: {}.\n Exception:{}").format(filename, ex)) |
266
|
|
|
return |
267
|
|
|
self._loadFileToUI() |
268
|
|
|
self._settings.setValue("last_open_file", filename) |
269
|
|
|
self.updateRecentFile() |
270
|
|
|
|
271
|
|
|
recentFilesChanged = QtCore.pyqtSignal() |
272
|
|
|
|
273
|
|
|
@QtCore.pyqtProperty('QVariant', notify=recentFilesChanged) |
274
|
|
|
def recentFiles(self): |
275
|
|
|
return self._recentFiles |
276
|
|
|
|
277
|
|
|
def updateRecentFile(self): |
278
|
|
|
if self._file.filename in self._recentFiles: |
279
|
|
|
self._recentFiles.remove(self._file.filename) |
280
|
|
|
self._recentFiles.insert(0, self._file.filename) |
281
|
|
|
self._recentFiles = self._recentFiles[:int(self._settings.value("max_recent_files", 6))] |
282
|
|
|
self._settings.setValue("recent_files", self._recentFiles) |
283
|
|
|
self.recentFilesChanged.emit() |
284
|
|
|
|
285
|
|
|
def _loadFileToUI(self): |
286
|
|
|
self.applyFilters() |
287
|
|
|
self._updateCompletionStrings() |
288
|
|
|
self._updateFilterTree() |
289
|
|
|
|
290
|
|
|
@QtCore.pyqtSlot('QVariant') |
291
|
|
|
def completeTask(self, task): |
292
|
|
|
if not task.is_complete: |
293
|
|
|
if task.recursion is not None and task.due is not None: |
294
|
|
|
new_task = tasklib.recurTask(task) |
295
|
|
|
self._file.addTask(new_task) |
296
|
|
|
task.setCompleted() |
297
|
|
|
else: |
298
|
|
|
task.setPending() |
299
|
|
|
|
300
|
|
|
|