Mercurial Repositories > eric / file comparison
comparison: QScintilla/Editor.py
QScintilla/Editor.py
- branch
- maintenance
- changeset 6319
- df201b9fbad4
- parent 6273
- 0daf79d65080
- parent 6306
- af71f34a0cfb
- child 6455
- 22a6fc33ab6d
equal
deleted
inserted
replaced
| 6274:44249d49d892 | 6319:df201b9fbad4 |
|---|---|
| 27 | 27 |
| 28 from E5Gui.E5Application import e5App | 28 from E5Gui.E5Application import e5App |
| 29 from E5Gui import E5FileDialog, E5MessageBox | 29 from E5Gui import E5FileDialog, E5MessageBox |
| 30 from E5Utilities.E5Cache import E5Cache | 30 from E5Utilities.E5Cache import E5Cache |
| 31 | 31 |
| 32 from .QsciScintillaCompat import QsciScintillaCompat, QSCINTILLA_VERSION | 32 from .QsciScintillaCompat import QsciScintillaCompat |
| 33 from .EditorMarkerMap import EditorMarkerMap | 33 from .EditorMarkerMap import EditorMarkerMap |
| 34 | 34 |
| 35 import Preferences | 35 import Preferences |
| 36 import Utilities | 36 import Utilities |
| 37 from Utilities import MouseUtilities | 37 from Utilities import MouseUtilities |
| 271 # connect signals before loading the text | 271 # connect signals before loading the text |
| 272 self.modificationChanged.connect(self.__modificationChanged) | 272 self.modificationChanged.connect(self.__modificationChanged) |
| 273 self.cursorPositionChanged.connect(self.__cursorPositionChanged) | 273 self.cursorPositionChanged.connect(self.__cursorPositionChanged) |
| 274 self.modificationAttempted.connect(self.__modificationReadOnly) | 274 self.modificationAttempted.connect(self.__modificationReadOnly) |
| 275 | 275 |
| 276 # margins layout | |
| 277 if QSCINTILLA_VERSION() >= 0x020301: | |
| 278 self.__unifiedMargins = Preferences.getEditor("UnifiedMargins") | |
| 279 else: | |
| 280 self.__unifiedMargins = True | |
| 281 | |
| 282 # define the margins markers | 276 # define the margins markers |
| 283 self.__changeMarkerSaved = self.markerDefine( | 277 self.__changeMarkerSaved = self.markerDefine( |
| 284 self.__createChangeMarkerPixmap( | 278 self.__createChangeMarkerPixmap( |
| 285 "OnlineChangeTraceMarkerSaved")) | 279 "OnlineChangeTraceMarkerSaved")) |
| 286 self.__changeMarkerUnsaved = self.markerDefine( | 280 self.__changeMarkerUnsaved = self.markerDefine( |
| 414 self.__acWatchdog.setInterval( | 408 self.__acWatchdog.setInterval( |
| 415 Preferences.getEditor("AutoCompletionWatchdogTime")) | 409 Preferences.getEditor("AutoCompletionWatchdogTime")) |
| 416 self.__acWatchdog.timeout.connect(self.autoCompleteQScintilla) | 410 self.__acWatchdog.timeout.connect(self.autoCompleteQScintilla) |
| 417 | 411 |
| 418 self.userListActivated.connect(self.__completionListSelected) | 412 self.userListActivated.connect(self.__completionListSelected) |
| 419 self.SCN_CHARADDED.connect(self.__charAddedPermanent) | 413 self.SCN_CHARADDED.connect(self.__charAdded) |
| 414 self.SCN_AUTOCCANCELLED.connect(self.__autocompletionCancelled) | |
| 420 | 415 |
| 421 self.__completionListHookFunctions = {} | 416 self.__completionListHookFunctions = {} |
| 422 self.__completionListAsyncHookFunctions = {} | 417 self.__completionListAsyncHookFunctions = {} |
| 423 self.__setAutoCompletion() | 418 self.__setAutoCompletion() |
| 424 | 419 |
| 1147 """ | 1142 """ |
| 1148 Private method used to setup the context menu for the margins. | 1143 Private method used to setup the context menu for the margins. |
| 1149 """ | 1144 """ |
| 1150 self.marginMenuActs = {} | 1145 self.marginMenuActs = {} |
| 1151 | 1146 |
| 1152 if self.__unifiedMargins: | |
| 1153 self.__initContextMenuUnifiedMargins() | |
| 1154 else: | |
| 1155 self.__initContextMenuSeparateMargins() | |
| 1156 | |
| 1157 def __initContextMenuSeparateMargins(self): | |
| 1158 """ | |
| 1159 Private method used to setup the context menu for the separated | |
| 1160 margins. | |
| 1161 """ | |
| 1162 # bookmark margin | 1147 # bookmark margin |
| 1163 self.bmMarginMenu = QMenu() | 1148 self.bmMarginMenu = QMenu() |
| 1164 | 1149 |
| 1165 self.bmMarginMenu.addAction( | 1150 self.bmMarginMenu.addAction( |
| 1166 self.tr('Toggle bookmark'), self.menuToggleBookmark) | 1151 self.tr('Toggle bookmark'), self.menuToggleBookmark) |
| 1196 self.marginMenuActs["ClearBreakpoint"] = self.bpMarginMenu.addAction( | 1181 self.marginMenuActs["ClearBreakpoint"] = self.bpMarginMenu.addAction( |
| 1197 self.tr('Clear all breakpoints'), self.__menuClearBreakpoints) | 1182 self.tr('Clear all breakpoints'), self.__menuClearBreakpoints) |
| 1198 | 1183 |
| 1199 self.bpMarginMenu.aboutToShow.connect( | 1184 self.bpMarginMenu.aboutToShow.connect( |
| 1200 lambda: self.__showContextMenuMargin(self.bpMarginMenu)) | 1185 lambda: self.__showContextMenuMargin(self.bpMarginMenu)) |
| 1186 | |
| 1187 # fold margin | |
| 1188 self.foldMarginMenu = QMenu() | |
| 1189 | |
| 1190 self.marginMenuActs["ToggleAllFolds"] = \ | |
| 1191 self.foldMarginMenu.addAction( | |
| 1192 self.tr("Toggle all folds"), | |
| 1193 self.foldAll) | |
| 1194 self.marginMenuActs["ToggleAllFoldsAndChildren"] = \ | |
| 1195 self.foldMarginMenu.addAction( | |
| 1196 self.tr("Toggle all folds (including children)"), | |
| 1197 lambda: self.foldAll(True)) | |
| 1198 self.marginMenuActs["ToggleCurrentFold"] = \ | |
| 1199 self.foldMarginMenu.addAction( | |
| 1200 self.tr("Toggle current fold"), | |
| 1201 self.toggleCurrentFold) | |
| 1202 self.foldMarginMenu.addSeparator() | |
| 1203 self.marginMenuActs["ExpandChildren"] = \ | |
| 1204 self.foldMarginMenu.addAction( | |
| 1205 self.tr("Expand (including children)"), | |
| 1206 self.__contextMenuExpandFoldWithChildren) | |
| 1207 self.marginMenuActs["CollapseChildren"] = \ | |
| 1208 self.foldMarginMenu.addAction( | |
| 1209 self.tr("Collapse (including children)"), | |
| 1210 self.__contextMenuCollapseFoldWithChildren) | |
| 1211 self.foldMarginMenu.addSeparator() | |
| 1212 self.marginMenuActs["ClearAllFolds"] = \ | |
| 1213 self.foldMarginMenu.addAction( | |
| 1214 self.tr("Clear all folds"), | |
| 1215 self.clearFolds) | |
| 1216 | |
| 1217 self.foldMarginMenu.aboutToShow.connect( | |
| 1218 lambda: self.__showContextMenuMargin(self.foldMarginMenu)) | |
| 1201 | 1219 |
| 1202 # indicator margin | 1220 # indicator margin |
| 1203 self.indicMarginMenu = QMenu() | 1221 self.indicMarginMenu = QMenu() |
| 1204 | 1222 |
| 1205 self.marginMenuActs["GotoSyntaxError"] = \ | 1223 self.marginMenuActs["GotoSyntaxError"] = \ |
| 1251 self.tr('Clear changes'), self.__reinitOnlineChangeTrace) | 1269 self.tr('Clear changes'), self.__reinitOnlineChangeTrace) |
| 1252 | 1270 |
| 1253 self.indicMarginMenu.aboutToShow.connect( | 1271 self.indicMarginMenu.aboutToShow.connect( |
| 1254 lambda: self.__showContextMenuMargin(self.indicMarginMenu)) | 1272 lambda: self.__showContextMenuMargin(self.indicMarginMenu)) |
| 1255 | 1273 |
| 1256 def __initContextMenuUnifiedMargins(self): | |
| 1257 """ | |
| 1258 Private method used to setup the context menu for the unified margins. | |
| 1259 """ | |
| 1260 self.marginMenu = QMenu() | |
| 1261 | |
| 1262 self.marginMenu.addAction( | |
| 1263 self.tr('Toggle bookmark'), self.menuToggleBookmark) | |
| 1264 self.marginMenuActs["NextBookmark"] = self.marginMenu.addAction( | |
| 1265 self.tr('Next bookmark'), self.nextBookmark) | |
| 1266 self.marginMenuActs["PreviousBookmark"] = self.marginMenu.addAction( | |
| 1267 self.tr('Previous bookmark'), self.previousBookmark) | |
| 1268 self.marginMenuActs["ClearBookmark"] = self.marginMenu.addAction( | |
| 1269 self.tr('Clear all bookmarks'), self.clearBookmarks) | |
| 1270 self.marginMenu.addSeparator() | |
| 1271 self.marginMenuActs["GotoSyntaxError"] = self.marginMenu.addAction( | |
| 1272 self.tr('Goto syntax error'), self.gotoSyntaxError) | |
| 1273 self.marginMenuActs["ShowSyntaxError"] = self.marginMenu.addAction( | |
| 1274 self.tr('Show syntax error message'), self.__showSyntaxError) | |
| 1275 self.marginMenuActs["ClearSyntaxError"] = self.marginMenu.addAction( | |
| 1276 self.tr('Clear syntax error'), self.clearSyntaxError) | |
| 1277 self.marginMenu.addSeparator() | |
| 1278 self.marginMenuActs["NextWarningMarker"] = self.marginMenu.addAction( | |
| 1279 self.tr("Next warning"), self.nextWarning) | |
| 1280 self.marginMenuActs["PreviousWarningMarker"] = \ | |
| 1281 self.marginMenu.addAction( | |
| 1282 self.tr("Previous warning"), self.previousWarning) | |
| 1283 self.marginMenuActs["ShowWarning"] = self.marginMenu.addAction( | |
| 1284 self.tr('Show warning message'), self.__showWarning) | |
| 1285 self.marginMenuActs["ClearWarnings"] = self.marginMenu.addAction( | |
| 1286 self.tr('Clear warnings'), self.clearWarnings) | |
| 1287 self.marginMenu.addSeparator() | |
| 1288 self.marginMenuActs["Breakpoint"] = self.marginMenu.addAction( | |
| 1289 self.tr('Toggle breakpoint'), self.menuToggleBreakpoint) | |
| 1290 self.marginMenuActs["TempBreakpoint"] = self.marginMenu.addAction( | |
| 1291 self.tr('Toggle temporary breakpoint'), | |
| 1292 self.__menuToggleTemporaryBreakpoint) | |
| 1293 self.marginMenuActs["EditBreakpoint"] = self.marginMenu.addAction( | |
| 1294 self.tr('Edit breakpoint...'), self.menuEditBreakpoint) | |
| 1295 self.marginMenuActs["EnableBreakpoint"] = self.marginMenu.addAction( | |
| 1296 self.tr('Enable breakpoint'), | |
| 1297 self.__menuToggleBreakpointEnabled) | |
| 1298 self.marginMenuActs["NextBreakpoint"] = self.marginMenu.addAction( | |
| 1299 self.tr('Next breakpoint'), self.menuNextBreakpoint) | |
| 1300 self.marginMenuActs["PreviousBreakpoint"] = self.marginMenu.addAction( | |
| 1301 self.tr('Previous breakpoint'), self.menuPreviousBreakpoint) | |
| 1302 self.marginMenuActs["ClearBreakpoint"] = self.marginMenu.addAction( | |
| 1303 self.tr('Clear all breakpoints'), self.__menuClearBreakpoints) | |
| 1304 self.marginMenu.addSeparator() | |
| 1305 self.marginMenuActs["NextCoverageMarker"] = self.marginMenu.addAction( | |
| 1306 self.tr('Next uncovered line'), self.nextUncovered) | |
| 1307 self.marginMenuActs["PreviousCoverageMarker"] = \ | |
| 1308 self.marginMenu.addAction( | |
| 1309 self.tr('Previous uncovered line'), self.previousUncovered) | |
| 1310 self.marginMenu.addSeparator() | |
| 1311 self.marginMenuActs["NextTaskMarker"] = self.marginMenu.addAction( | |
| 1312 self.tr('Next task'), self.nextTask) | |
| 1313 self.marginMenuActs["PreviousTaskMarker"] = self.marginMenu.addAction( | |
| 1314 self.tr('Previous task'), self.previousTask) | |
| 1315 self.marginMenu.addSeparator() | |
| 1316 self.marginMenuActs["NextChangeMarker"] = self.marginMenu.addAction( | |
| 1317 self.tr('Next change'), self.nextChange) | |
| 1318 self.marginMenuActs["PreviousChangeMarker"] = \ | |
| 1319 self.marginMenu.addAction( | |
| 1320 self.tr('Previous change'), self.previousChange) | |
| 1321 self.marginMenuActs["ClearChangeMarkers"] = \ | |
| 1322 self.marginMenu.addAction( | |
| 1323 self.tr('Clear changes'), self.__reinitOnlineChangeTrace) | |
| 1324 self.marginMenu.addSeparator() | |
| 1325 self.marginMenuActs["LMBbookmarks"] = self.marginMenu.addAction( | |
| 1326 self.tr('LMB toggles bookmarks'), self.__lmBbookmarks) | |
| 1327 self.marginMenuActs["LMBbookmarks"].setCheckable(True) | |
| 1328 self.marginMenuActs["LMBbookmarks"].setChecked(False) | |
| 1329 self.marginMenuActs["LMBbreakpoints"] = self.marginMenu.addAction( | |
| 1330 self.tr('LMB toggles breakpoints'), self.__lmBbreakpoints) | |
| 1331 self.marginMenuActs["LMBbreakpoints"].setCheckable(True) | |
| 1332 self.marginMenuActs["LMBbreakpoints"].setChecked(True) | |
| 1333 | |
| 1334 self.marginMenu.aboutToShow.connect( | |
| 1335 lambda: self.__showContextMenuMargin(self.marginMenu)) | |
| 1336 | |
| 1337 def __exportMenuTriggered(self, act): | 1274 def __exportMenuTriggered(self, act): |
| 1338 """ | 1275 """ |
| 1339 Private method to handle the selection of an export format. | 1276 Private method to handle the selection of an export format. |
| 1340 | 1277 |
| 1341 @param act reference to the action that was triggered (QAction) | 1278 @param act reference to the action that was triggered (QAction) |
| 2356 if dlg.exec_() == QDialog.Accepted: | 2293 if dlg.exec_() == QDialog.Accepted: |
| 2357 cond, temp, enabled, ignorecount = dlg.getData() | 2294 cond, temp, enabled, ignorecount = dlg.getData() |
| 2358 self.breakpointModel.setBreakPointByIndex( | 2295 self.breakpointModel.setBreakPointByIndex( |
| 2359 index, self.fileName, ln, | 2296 index, self.fileName, ln, |
| 2360 (cond, temp, enabled, ignorecount)) | 2297 (cond, temp, enabled, ignorecount)) |
| 2298 break | |
| 2361 | 2299 |
| 2362 self.line = -1 | 2300 self.line = -1 |
| 2363 | 2301 |
| 2364 def menuNextBreakpoint(self): | 2302 def menuNextBreakpoint(self): |
| 2365 """ | 2303 """ |
| 3311 | 3249 |
| 3312 ########################################################################### | 3250 ########################################################################### |
| 3313 ## Utility methods below | 3251 ## Utility methods below |
| 3314 ########################################################################### | 3252 ########################################################################### |
| 3315 | 3253 |
| 3316 def ensureVisible(self, line): | 3254 def ensureVisible(self, line, expand=False): |
| 3317 """ | 3255 """ |
| 3318 Public slot to ensure, that the specified line is visible. | 3256 Public slot to ensure, that the specified line is visible. |
| 3319 | 3257 |
| 3320 @param line line number to make visible | 3258 @param line line number to make visible |
| 3259 @type int | |
| 3260 @keyparam expand flag indicating to expand all folds | |
| 3261 @type bool | |
| 3321 """ | 3262 """ |
| 3322 self.ensureLineVisible(line - 1) | 3263 self.ensureLineVisible(line - 1) |
| 3323 | 3264 if expand: |
| 3324 def ensureVisibleTop(self, line): | 3265 self.SendScintilla(QsciScintilla.SCI_FOLDCHILDREN, line - 1, |
| 3266 QsciScintilla.SC_FOLDACTION_EXPAND) | |
| 3267 | |
| 3268 def ensureVisibleTop(self, line, expand=False): | |
| 3325 """ | 3269 """ |
| 3326 Public slot to ensure, that the specified line is visible at the top | 3270 Public slot to ensure, that the specified line is visible at the top |
| 3327 of the editor. | 3271 of the editor. |
| 3328 | 3272 |
| 3329 @param line line number to make visible | 3273 @param line line number to make visible |
| 3330 """ | 3274 @type int |
| 3275 @keyparam expand flag indicating to expand all folds | |
| 3276 @type bool | |
| 3277 """ | |
| 3278 self.ensureVisible(line) | |
| 3331 self.setFirstVisibleLine(line - 1) | 3279 self.setFirstVisibleLine(line - 1) |
| 3280 self.ensureCursorVisible() | |
| 3281 if expand: | |
| 3282 self.SendScintilla(QsciScintilla.SCI_FOLDCHILDREN, line - 1, | |
| 3283 QsciScintilla.SC_FOLDACTION_EXPAND) | |
| 3332 | 3284 |
| 3333 def __marginClicked(self, margin, line, modifiers): | 3285 def __marginClicked(self, margin, line, modifiers): |
| 3334 """ | 3286 """ |
| 3335 Private slot to handle the marginClicked signal. | 3287 Private slot to handle the marginClicked signal. |
| 3336 | 3288 |
| 3337 @param margin id of the clicked margin (integer) | 3289 @param margin id of the clicked margin (integer) |
| 3338 @param line line number of the click (integer) | 3290 @param line line number of the click (integer) |
| 3339 @param modifiers keyboard modifiers (Qt.KeyboardModifiers) | 3291 @param modifiers keyboard modifiers (Qt.KeyboardModifiers) |
| 3340 """ | 3292 """ |
| 3341 if self.__unifiedMargins: | 3293 if margin == self.__bmMargin: |
| 3342 if margin == 1: | 3294 self.toggleBookmark(line + 1) |
| 3343 if modifiers & Qt.KeyboardModifiers(Qt.ShiftModifier): | 3295 elif margin == self.__bpMargin: |
| 3344 if self.marginMenuActs["LMBbreakpoints"].isChecked(): | 3296 self.__toggleBreakpoint(line + 1) |
| 3345 self.toggleBookmark(line + 1) | 3297 elif margin == self.__indicMargin: |
| 3346 else: | 3298 if self.markersAtLine(line) & (1 << self.syntaxerror): |
| 3347 self.__toggleBreakpoint(line + 1) | 3299 self.__showSyntaxError(line) |
| 3348 elif modifiers & Qt.KeyboardModifiers(Qt.ControlModifier): | 3300 elif self.markersAtLine(line) & (1 << self.warning): |
| 3349 if self.markersAtLine(line) & (1 << self.syntaxerror): | 3301 self.__showWarning(line) |
| 3350 self.__showSyntaxError(line) | |
| 3351 elif self.markersAtLine(line) & (1 << self.warning): | |
| 3352 self.__showWarning(line) | |
| 3353 else: | |
| 3354 if self.marginMenuActs["LMBbreakpoints"].isChecked(): | |
| 3355 self.__toggleBreakpoint(line + 1) | |
| 3356 else: | |
| 3357 self.toggleBookmark(line + 1) | |
| 3358 else: | |
| 3359 if margin == self.__bmMargin: | |
| 3360 self.toggleBookmark(line + 1) | |
| 3361 elif margin == self.__bpMargin: | |
| 3362 self.__toggleBreakpoint(line + 1) | |
| 3363 elif margin == self.__indicMargin: | |
| 3364 if self.markersAtLine(line) & (1 << self.syntaxerror): | |
| 3365 self.__showSyntaxError(line) | |
| 3366 elif self.markersAtLine(line) & (1 << self.warning): | |
| 3367 self.__showWarning(line) | |
| 3368 | 3302 |
| 3369 def handleMonospacedEnable(self): | 3303 def handleMonospacedEnable(self): |
| 3370 """ | 3304 """ |
| 3371 Public slot to handle the Use Monospaced Font context menu entry. | 3305 Public slot to handle the Use Monospaced Font context menu entry. |
| 3372 """ | 3306 """ |
| 4019 if self.lexer_ and self.lexer_.hasSmartIndent(): | 3953 if self.lexer_ and self.lexer_.hasSmartIndent(): |
| 4020 self.lexer_.smartIndentLine(self) | 3954 self.lexer_.smartIndentLine(self) |
| 4021 else: | 3955 else: |
| 4022 self.__indentLine(True) | 3956 self.__indentLine(True) |
| 4023 | 3957 |
| 4024 def gotoLine(self, line, pos=1, firstVisible=False): | 3958 def gotoLine(self, line, pos=1, firstVisible=False, expand=False): |
| 4025 """ | 3959 """ |
| 4026 Public slot to jump to the beginning of a line. | 3960 Public slot to jump to the beginning of a line. |
| 4027 | 3961 |
| 4028 @param line line number to go to (integer) | 3962 @param line line number to go to |
| 4029 @keyparam pos position in line to go to (integer) | 3963 @type int |
| 3964 @keyparam pos position in line to go to | |
| 3965 @type int | |
| 4030 @keyparam firstVisible flag indicating to make the line the first | 3966 @keyparam firstVisible flag indicating to make the line the first |
| 4031 visible line (boolean) | 3967 visible line |
| 3968 @type bool | |
| 3969 @keyparam expand flag indicating to expand all folds | |
| 3970 @type bool | |
| 4032 """ | 3971 """ |
| 4033 self.setCursorPosition(line - 1, pos - 1) | 3972 self.setCursorPosition(line - 1, pos - 1) |
| 4034 if firstVisible: | 3973 if firstVisible: |
| 4035 self.ensureVisibleTop(line) | 3974 self.ensureVisibleTop(line, expand) |
| 4036 else: | 3975 else: |
| 4037 self.ensureVisible(line) | 3976 self.ensureVisible(line, expand) |
| 4038 | 3977 |
| 4039 def __textChanged(self): | 3978 def __textChanged(self): |
| 4040 """ | 3979 """ |
| 4041 Private slot to handle a change of the editor text. | 3980 Private slot to handle a change of the editor text. |
| 4042 | 3981 |
| 4140 | 4079 |
| 4141 # read the typing completer settings | 4080 # read the typing completer settings |
| 4142 if self.completer is not None: | 4081 if self.completer is not None: |
| 4143 self.completer.readSettings() | 4082 self.completer.readSettings() |
| 4144 | 4083 |
| 4145 # set the margins layout | |
| 4146 if QSCINTILLA_VERSION() >= 0x020301: | |
| 4147 self.__unifiedMargins = Preferences.getEditor("UnifiedMargins") | |
| 4148 | |
| 4149 # set the line marker colours or pixmap | 4084 # set the line marker colours or pixmap |
| 4150 if Preferences.getEditor("LineMarkersBackground"): | 4085 if Preferences.getEditor("LineMarkersBackground"): |
| 4151 self.markerDefine(QsciScintilla.Background, self.currentline) | 4086 self.markerDefine(QsciScintilla.Background, self.currentline) |
| 4152 self.markerDefine(QsciScintilla.Background, self.errorline) | 4087 self.markerDefine(QsciScintilla.Background, self.errorline) |
| 4153 self.__setLineMarkerColours() | 4088 self.__setLineMarkerColours() |
| 4221 "OnlineChangeTraceMarkerSaved"), self.__changeMarkerSaved) | 4156 "OnlineChangeTraceMarkerSaved"), self.__changeMarkerSaved) |
| 4222 | 4157 |
| 4223 # refresh the annotations display | 4158 # refresh the annotations display |
| 4224 self.__refreshAnnotations() | 4159 self.__refreshAnnotations() |
| 4225 | 4160 |
| 4161 self.__markerMap.setMapPosition( | |
| 4162 Preferences.getEditor("ShowMarkerMapOnRight")) | |
| 4226 self.__markerMap.initColors() | 4163 self.__markerMap.initColors() |
| 4227 | 4164 |
| 4228 self.settingsRead.emit() | 4165 self.settingsRead.emit() |
| 4229 | 4166 |
| 4230 def __setLineMarkerColours(self): | 4167 def __setLineMarkerColours(self): |
| 4257 self.setMarginMarkerMask(margin, 0) | 4194 self.setMarginMarkerMask(margin, 0) |
| 4258 self.setMarginWidth(margin, 0) | 4195 self.setMarginWidth(margin, 0) |
| 4259 self.setMarginSensitivity(margin, False) | 4196 self.setMarginSensitivity(margin, False) |
| 4260 | 4197 |
| 4261 # set marker margin(s) settings | 4198 # set marker margin(s) settings |
| 4262 if self.__unifiedMargins: | 4199 self.__bmMargin = 0 |
| 4263 margin1Mask = (1 << self.breakpoint) | \ | 4200 self.__linenoMargin = 1 |
| 4264 (1 << self.cbreakpoint) | \ | 4201 self.__bpMargin = 2 |
| 4265 (1 << self.tbreakpoint) | \ | 4202 self.__foldMargin = 3 |
| 4266 (1 << self.tcbreakpoint) | \ | 4203 self.__indicMargin = 4 |
| 4267 (1 << self.dbreakpoint) | \ | 4204 |
| 4268 (1 << self.currentline) | \ | 4205 marginBmMask = (1 << self.bookmark) |
| 4269 (1 << self.errorline) | \ | 4206 self.setMarginWidth(self.__bmMargin, 16) |
| 4270 (1 << self.bookmark) | \ | 4207 self.setMarginSensitivity(self.__bmMargin, True) |
| 4271 (1 << self.syntaxerror) | \ | 4208 self.setMarginMarkerMask(self.__bmMargin, marginBmMask) |
| 4209 | |
| 4210 marginBpMask = (1 << self.breakpoint) | \ | |
| 4211 (1 << self.cbreakpoint) | \ | |
| 4212 (1 << self.tbreakpoint) | \ | |
| 4213 (1 << self.tcbreakpoint) | \ | |
| 4214 (1 << self.dbreakpoint) | |
| 4215 self.setMarginWidth(self.__bpMargin, 16) | |
| 4216 self.setMarginSensitivity(self.__bpMargin, True) | |
| 4217 self.setMarginMarkerMask(self.__bpMargin, marginBpMask) | |
| 4218 | |
| 4219 marginIndicMask = (1 << self.syntaxerror) | \ | |
| 4272 (1 << self.notcovered) | \ | 4220 (1 << self.notcovered) | \ |
| 4273 (1 << self.taskmarker) | \ | 4221 (1 << self.taskmarker) | \ |
| 4274 (1 << self.warning) | \ | 4222 (1 << self.warning) | \ |
| 4275 (1 << self.__changeMarkerUnsaved) | \ | 4223 (1 << self.__changeMarkerUnsaved) | \ |
| 4276 (1 << self.__changeMarkerSaved) | 4224 (1 << self.__changeMarkerSaved) | \ |
| 4277 self.setMarginWidth(1, 16) | 4225 (1 << self.currentline) | \ |
| 4278 self.setMarginSensitivity(1, True) | 4226 (1 << self.errorline) |
| 4279 self.setMarginMarkerMask(1, margin1Mask) | 4227 self.setMarginWidth(self.__indicMargin, 16) |
| 4280 | 4228 self.setMarginSensitivity(self.__indicMargin, True) |
| 4281 self.__linenoMargin = 0 | 4229 self.setMarginMarkerMask(self.__indicMargin, marginIndicMask) |
| 4282 self.__foldMargin = 2 | |
| 4283 else: | |
| 4284 | |
| 4285 self.__bmMargin = 0 | |
| 4286 self.__linenoMargin = 1 | |
| 4287 self.__bpMargin = 2 | |
| 4288 self.__foldMargin = 3 | |
| 4289 self.__indicMargin = 4 | |
| 4290 | |
| 4291 marginBmMask = (1 << self.bookmark) | |
| 4292 self.setMarginWidth(self.__bmMargin, 16) | |
| 4293 self.setMarginSensitivity(self.__bmMargin, True) | |
| 4294 self.setMarginMarkerMask(self.__bmMargin, marginBmMask) | |
| 4295 | |
| 4296 marginBpMask = (1 << self.breakpoint) | \ | |
| 4297 (1 << self.cbreakpoint) | \ | |
| 4298 (1 << self.tbreakpoint) | \ | |
| 4299 (1 << self.tcbreakpoint) | \ | |
| 4300 (1 << self.dbreakpoint) | |
| 4301 self.setMarginWidth(self.__bpMargin, 16) | |
| 4302 self.setMarginSensitivity(self.__bpMargin, True) | |
| 4303 self.setMarginMarkerMask(self.__bpMargin, marginBpMask) | |
| 4304 | |
| 4305 marginIndicMask = (1 << self.syntaxerror) | \ | |
| 4306 (1 << self.notcovered) | \ | |
| 4307 (1 << self.taskmarker) | \ | |
| 4308 (1 << self.warning) | \ | |
| 4309 (1 << self.__changeMarkerUnsaved) | \ | |
| 4310 (1 << self.__changeMarkerSaved) | \ | |
| 4311 (1 << self.currentline) | \ | |
| 4312 (1 << self.errorline) | |
| 4313 self.setMarginWidth(self.__indicMargin, 16) | |
| 4314 self.setMarginSensitivity(self.__indicMargin, True) | |
| 4315 self.setMarginMarkerMask(self.__indicMargin, marginIndicMask) | |
| 4316 | 4230 |
| 4317 # set linenumber margin settings | 4231 # set linenumber margin settings |
| 4318 linenoMargin = Preferences.getEditor("LinenoMargin") | 4232 linenoMargin = Preferences.getEditor("LinenoMargin") |
| 4319 self.setMarginLineNumbers(self.__linenoMargin, linenoMargin) | 4233 self.setMarginLineNumbers(self.__linenoMargin, linenoMargin) |
| 4320 if linenoMargin: | 4234 if linenoMargin: |
| 4505 Preferences.getEditor("AutoCompletionFillups")) | 4419 Preferences.getEditor("AutoCompletionFillups")) |
| 4506 self.setAutoCompletionCaseSensitivity( | 4420 self.setAutoCompletionCaseSensitivity( |
| 4507 Preferences.getEditor("AutoCompletionCaseSensitivity")) | 4421 Preferences.getEditor("AutoCompletionCaseSensitivity")) |
| 4508 self.setAutoCompletionReplaceWord( | 4422 self.setAutoCompletionReplaceWord( |
| 4509 Preferences.getEditor("AutoCompletionReplaceWord")) | 4423 Preferences.getEditor("AutoCompletionReplaceWord")) |
| 4424 self.setAutoCompletionThreshold(0) | |
| 4510 try: | 4425 try: |
| 4511 self.setAutoCompletionUseSingle( | 4426 self.setAutoCompletionUseSingle( |
| 4512 Preferences.getEditor("AutoCompletionShowSingle")) | 4427 Preferences.getEditor("AutoCompletionShowSingle")) |
| 4513 except AttributeError: | 4428 except AttributeError: |
| 4514 self.setAutoCompletionShowSingle( | 4429 self.setAutoCompletionShowSingle( |
| 4518 self.setAutoCompletionSource(QsciScintilla.AcsDocument) | 4433 self.setAutoCompletionSource(QsciScintilla.AcsDocument) |
| 4519 elif autoCompletionSource == QsciScintilla.AcsAPIs: | 4434 elif autoCompletionSource == QsciScintilla.AcsAPIs: |
| 4520 self.setAutoCompletionSource(QsciScintilla.AcsAPIs) | 4435 self.setAutoCompletionSource(QsciScintilla.AcsAPIs) |
| 4521 else: | 4436 else: |
| 4522 self.setAutoCompletionSource(QsciScintilla.AcsAll) | 4437 self.setAutoCompletionSource(QsciScintilla.AcsAll) |
| 4523 if Preferences.getEditor("AutoCompletionEnabled"): | 4438 |
| 4524 if not self.__completionListHookFunctions and \ | 4439 self.maxLines = Preferences.getEditor("AutoCompletionMaxLines") |
| 4525 not self.__completionListAsyncHookFunctions: | 4440 self.maxChars = Preferences.getEditor("AutoCompletionMaxChars") |
| 4526 self.setAutoCompletionThreshold( | |
| 4527 Preferences.getEditor("AutoCompletionThreshold")) | |
| 4528 else: | |
| 4529 self.setAutoCompletionThreshold(0) | |
| 4530 else: | |
| 4531 self.setAutoCompletionThreshold(-1) | |
| 4532 self.setAutoCompletionSource(QsciScintilla.AcsNone) | |
| 4533 | 4441 |
| 4534 def __setCallTips(self): | 4442 def __setCallTips(self): |
| 4535 """ | 4443 """ |
| 4536 Private method to configure the calltips function. | 4444 Private method to configure the calltips function. |
| 4537 """ | 4445 """ |
| 4599 | 4507 |
| 4600 @param enable flag indicating the desired autocompletion status | 4508 @param enable flag indicating the desired autocompletion status |
| 4601 (boolean) | 4509 (boolean) |
| 4602 """ | 4510 """ |
| 4603 if enable: | 4511 if enable: |
| 4604 self.setAutoCompletionThreshold( | |
| 4605 Preferences.getEditor("AutoCompletionThreshold")) | |
| 4606 autoCompletionSource = \ | 4512 autoCompletionSource = \ |
| 4607 Preferences.getEditor("AutoCompletionSource") | 4513 Preferences.getEditor("AutoCompletionSource") |
| 4608 if autoCompletionSource == QsciScintilla.AcsDocument: | 4514 if autoCompletionSource == QsciScintilla.AcsDocument: |
| 4609 self.setAutoCompletionSource(QsciScintilla.AcsDocument) | 4515 self.setAutoCompletionSource(QsciScintilla.AcsDocument) |
| 4610 elif autoCompletionSource == QsciScintilla.AcsAPIs: | 4516 elif autoCompletionSource == QsciScintilla.AcsAPIs: |
| 4611 self.setAutoCompletionSource(QsciScintilla.AcsAPIs) | 4517 self.setAutoCompletionSource(QsciScintilla.AcsAPIs) |
| 4612 else: | 4518 else: |
| 4613 self.setAutoCompletionSource(QsciScintilla.AcsAll) | 4519 self.setAutoCompletionSource(QsciScintilla.AcsAll) |
| 4614 else: | 4520 |
| 4615 self.setAutoCompletionThreshold(-1) | |
| 4616 self.setAutoCompletionSource(QsciScintilla.AcsNone) | |
| 4617 | |
| 4618 def __toggleAutoCompletionEnable(self): | 4521 def __toggleAutoCompletionEnable(self): |
| 4619 """ | 4522 """ |
| 4620 Private slot to handle the Enable Autocompletion context menu entry. | 4523 Private slot to handle the Enable Autocompletion context menu entry. |
| 4621 """ | 4524 """ |
| 4622 if self.menuActs["AutoCompletionEnable"].isChecked(): | 4525 if self.menuActs["AutoCompletionEnable"].isChecked(): |
| 4632 """ | 4535 """ |
| 4633 Private slot called to handle the user entering a character. | 4536 Private slot called to handle the user entering a character. |
| 4634 | 4537 |
| 4635 @param charNumber value of the character entered (integer) | 4538 @param charNumber value of the character entered (integer) |
| 4636 """ | 4539 """ |
| 4540 char = chr(charNumber) | |
| 4541 # update code documentation viewer | |
| 4542 if char == "(" and \ | |
| 4543 Preferences.getDocuViewer("ShowInfoOnOpenParenthesis"): | |
| 4544 self.vm.showEditorInfo(self) | |
| 4545 | |
| 4637 if self.isListActive(): | 4546 if self.isListActive(): |
| 4638 char = chr(charNumber) | |
| 4639 if self.__isStartChar(char): | 4547 if self.__isStartChar(char): |
| 4640 self.cancelList() | 4548 self.cancelList() |
| 4641 self.autoComplete(auto=True, context=True) | 4549 self.autoComplete(auto=True, context=True) |
| 4642 return | 4550 return |
| 4643 elif char == '(': | 4551 elif char == '(': |
| 4716 self.tr("""The completion list provider '{0}' was already""" | 4624 self.tr("""The completion list provider '{0}' was already""" |
| 4717 """ registered. Ignoring duplicate request.""") | 4625 """ registered. Ignoring duplicate request.""") |
| 4718 .format(key)) | 4626 .format(key)) |
| 4719 return | 4627 return |
| 4720 | 4628 |
| 4721 if not self.__completionListHookFunctions and \ | |
| 4722 not self.__completionListAsyncHookFunctions: | |
| 4723 if self.autoCompletionThreshold() > 0: | |
| 4724 self.setAutoCompletionThreshold(0) | |
| 4725 self.SCN_CHARADDED.connect(self.__charAdded) | |
| 4726 self.SCN_AUTOCCANCELLED.connect(self.__autocompletionCancelled) | |
| 4727 | |
| 4728 if asynchroneous: | 4629 if asynchroneous: |
| 4729 self.__completionListAsyncHookFunctions[key] = func | 4630 self.__completionListAsyncHookFunctions[key] = func |
| 4730 else: | 4631 else: |
| 4731 self.__completionListHookFunctions[key] = func | 4632 self.__completionListHookFunctions[key] = func |
| 4732 | 4633 |
| 4740 """ | 4641 """ |
| 4741 if key in self.__completionListHookFunctions: | 4642 if key in self.__completionListHookFunctions: |
| 4742 del self.__completionListHookFunctions[key] | 4643 del self.__completionListHookFunctions[key] |
| 4743 elif key in self.__completionListAsyncHookFunctions: | 4644 elif key in self.__completionListAsyncHookFunctions: |
| 4744 del self.__completionListAsyncHookFunctions[key] | 4645 del self.__completionListAsyncHookFunctions[key] |
| 4745 | |
| 4746 if not self.__completionListHookFunctions and \ | |
| 4747 not self.__completionListAsyncHookFunctions: | |
| 4748 self.SCN_CHARADDED.disconnect(self.__charAdded) | |
| 4749 self.SCN_AUTOCCANCELLED.disconnect(self.__autocompletionCancelled) | |
| 4750 if self.autoCompletionThreshold() == 0: | |
| 4751 self.setAutoCompletionThreshold( | |
| 4752 Preferences.getEditor("AutoCompletionThreshold")) | |
| 4753 | 4646 |
| 4754 def getCompletionListHook(self, key): | 4647 def getCompletionListHook(self, key): |
| 4755 """ | 4648 """ |
| 4756 Public method to get the registered completion list provider. | 4649 Public method to get the registered completion list provider. |
| 4757 | 4650 |
| 4769 | 4662 |
| 4770 @keyparam auto flag indicating a call from the __charAdded method | 4663 @keyparam auto flag indicating a call from the __charAdded method |
| 4771 (boolean) | 4664 (boolean) |
| 4772 @keyparam context flag indicating to complete a context (boolean) | 4665 @keyparam context flag indicating to complete a context (boolean) |
| 4773 """ | 4666 """ |
| 4774 if auto and self.autoCompletionThreshold() == -1: | 4667 if auto and not Preferences.getEditor("AutoCompletionEnabled"): |
| 4775 # auto-completion is disabled | 4668 # auto-completion is disabled |
| 4776 return | 4669 return |
| 4777 | 4670 |
| 4778 if self.isListActive(): | 4671 if self.isListActive(): |
| 4779 self.cancelList() | 4672 self.cancelList() |
| 5146 | 5039 |
| 5147 ################################################################# | 5040 ################################################################# |
| 5148 ## Methods needed by the code documentation viewer | 5041 ## Methods needed by the code documentation viewer |
| 5149 ################################################################# | 5042 ################################################################# |
| 5150 | 5043 |
| 5151 def __charAddedPermanent(self, charNumber): | |
| 5152 """ | |
| 5153 Private slot called to handle the user entering a character. | |
| 5154 | |
| 5155 Note: This slot is always connected independent of the auto-completion | |
| 5156 and calltips handling __charAdded() slot. | |
| 5157 | |
| 5158 @param charNumber value of the character entered (integer) | |
| 5159 """ | |
| 5160 char = chr(charNumber) | |
| 5161 if char == "(" and \ | |
| 5162 Preferences.getDocuViewer("ShowInfoOnOpenParenthesis"): | |
| 5163 self.vm.showEditorInfo(self) | |
| 5164 | |
| 5165 def __showCodeInfo(self): | 5044 def __showCodeInfo(self): |
| 5166 """ | 5045 """ |
| 5167 Private slot to handle the context menu action to show code info. | 5046 Private slot to handle the context menu action to show code info. |
| 5168 """ | 5047 """ |
| 5169 self.vm.showEditorInfo(self) | 5048 self.vm.showEditorInfo(self) |
| 5201 self.spellingMenu.popup(evt.globalPos()) | 5080 self.spellingMenu.popup(evt.globalPos()) |
| 5202 else: | 5081 else: |
| 5203 self.menu.popup(evt.globalPos()) | 5082 self.menu.popup(evt.globalPos()) |
| 5204 else: | 5083 else: |
| 5205 self.line = self.lineAt(evt.pos()) | 5084 self.line = self.lineAt(evt.pos()) |
| 5206 if self.__unifiedMargins: | 5085 if self.__marginNumber(evt.x()) in [self.__bmMargin, |
| 5207 self.marginMenu.popup(evt.globalPos()) | 5086 self.__linenoMargin]: |
| 5208 else: | 5087 self.bmMarginMenu.popup(evt.globalPos()) |
| 5209 if self.__marginNumber(evt.x()) in [self.__bmMargin, | 5088 elif self.__marginNumber(evt.x()) == self.__bpMargin: |
| 5210 self.__linenoMargin]: | 5089 self.bpMarginMenu.popup(evt.globalPos()) |
| 5211 self.bmMarginMenu.popup(evt.globalPos()) | 5090 elif self.__marginNumber(evt.x()) == self.__indicMargin: |
| 5212 elif self.__marginNumber(evt.x()) == self.__bpMargin: | 5091 self.indicMarginMenu.popup(evt.globalPos()) |
| 5213 self.bpMarginMenu.popup(evt.globalPos()) | 5092 elif self.__marginNumber(evt.x()) == self.__foldMargin: |
| 5214 elif self.__marginNumber(evt.x()) == self.__indicMargin: | 5093 self.foldMarginMenu.popup(evt.globalPos()) |
| 5215 self.indicMarginMenu.popup(evt.globalPos()) | |
| 5216 | 5094 |
| 5217 def __showContextMenu(self): | 5095 def __showContextMenu(self): |
| 5218 """ | 5096 """ |
| 5219 Private slot handling the aboutToShow signal of the context menu. | 5097 Private slot handling the aboutToShow signal of the context menu. |
| 5220 """ | 5098 """ |
| 5331 os.path.isfile("{0}.coverage".format(basename)) or | 5209 os.path.isfile("{0}.coverage".format(basename)) or |
| 5332 os.path.isfile("{0}.coverage".format(tbasename))) and \ | 5210 os.path.isfile("{0}.coverage".format(tbasename))) and \ |
| 5333 (self.project.isPy3Project() or | 5211 (self.project.isPy3Project() or |
| 5334 self.project.isPy2Project()) | 5212 self.project.isPy2Project()) |
| 5335 | 5213 |
| 5336 # now check ourself | 5214 # now check ourselves |
| 5337 fn = self.getFileName() | 5215 fn = self.getFileName() |
| 5338 if fn is not None: | 5216 if fn is not None: |
| 5339 tfn = Utilities.getTestFileName(fn) | 5217 tfn = Utilities.getTestFileName(fn) |
| 5340 basename = os.path.splitext(fn)[0] | 5218 basename = os.path.splitext(fn)[0] |
| 5341 tbasename = os.path.splitext(tfn)[0] | 5219 tbasename = os.path.splitext(tfn)[0] |
| 5380 menu. | 5258 menu. |
| 5381 | 5259 |
| 5382 @param menu reference to the menu to be shown | 5260 @param menu reference to the menu to be shown |
| 5383 @type QMenu | 5261 @type QMenu |
| 5384 """ | 5262 """ |
| 5385 if self.fileName and self.isPyFile(): | 5263 if menu is self.bpMarginMenu: |
| 5386 self.marginMenuActs["Breakpoint"].setEnabled(True) | 5264 supportsDebugger = bool(self.fileName and self.isPyFile()) |
| 5387 self.marginMenuActs["TempBreakpoint"].setEnabled(True) | 5265 hasBreakpoints = bool(self.breaks) |
| 5388 if self.markersAtLine(self.line) & self.breakpointMask: | 5266 hasBreakpoint = bool( |
| 5389 self.marginMenuActs["EditBreakpoint"].setEnabled(True) | 5267 self.markersAtLine(self.line) & self.breakpointMask) |
| 5390 self.marginMenuActs["EnableBreakpoint"].setEnabled(True) | |
| 5391 else: | |
| 5392 self.marginMenuActs["EditBreakpoint"].setEnabled(False) | |
| 5393 self.marginMenuActs["EnableBreakpoint"].setEnabled(False) | |
| 5394 if self.markersAtLine(self.line) & (1 << self.dbreakpoint): | |
| 5395 self.marginMenuActs["EnableBreakpoint"].setText( | |
| 5396 self.tr('Enable breakpoint')) | |
| 5397 else: | |
| 5398 self.marginMenuActs["EnableBreakpoint"].setText( | |
| 5399 self.tr('Disable breakpoint')) | |
| 5400 if self.breaks: | |
| 5401 self.marginMenuActs["NextBreakpoint"].setEnabled(True) | |
| 5402 self.marginMenuActs["PreviousBreakpoint"].setEnabled(True) | |
| 5403 self.marginMenuActs["ClearBreakpoint"].setEnabled(True) | |
| 5404 else: | |
| 5405 self.marginMenuActs["NextBreakpoint"].setEnabled(False) | |
| 5406 self.marginMenuActs["PreviousBreakpoint"].setEnabled(False) | |
| 5407 self.marginMenuActs["ClearBreakpoint"].setEnabled(False) | |
| 5408 else: | |
| 5409 self.marginMenuActs["Breakpoint"].setEnabled(False) | |
| 5410 self.marginMenuActs["TempBreakpoint"].setEnabled(False) | |
| 5411 self.marginMenuActs["EditBreakpoint"].setEnabled(False) | |
| 5412 self.marginMenuActs["EnableBreakpoint"].setEnabled(False) | |
| 5413 self.marginMenuActs["NextBreakpoint"].setEnabled(False) | |
| 5414 self.marginMenuActs["PreviousBreakpoint"].setEnabled(False) | |
| 5415 self.marginMenuActs["ClearBreakpoint"].setEnabled(False) | |
| 5416 | 5268 |
| 5417 if self.bookmarks: | 5269 self.marginMenuActs["Breakpoint"].setEnabled(supportsDebugger) |
| 5418 self.marginMenuActs["NextBookmark"].setEnabled(True) | 5270 self.marginMenuActs["TempBreakpoint"].setEnabled(supportsDebugger) |
| 5419 self.marginMenuActs["PreviousBookmark"].setEnabled(True) | 5271 self.marginMenuActs["NextBreakpoint"].setEnabled( |
| 5420 self.marginMenuActs["ClearBookmark"].setEnabled(True) | 5272 supportsDebugger and hasBreakpoints) |
| 5421 else: | 5273 self.marginMenuActs["PreviousBreakpoint"].setEnabled( |
| 5422 self.marginMenuActs["NextBookmark"].setEnabled(False) | 5274 supportsDebugger and hasBreakpoints) |
| 5423 self.marginMenuActs["PreviousBookmark"].setEnabled(False) | 5275 self.marginMenuActs["ClearBreakpoint"].setEnabled( |
| 5424 self.marginMenuActs["ClearBookmark"].setEnabled(False) | 5276 supportsDebugger and hasBreakpoints) |
| 5277 self.marginMenuActs["EditBreakpoint"].setEnabled( | |
| 5278 supportsDebugger and hasBreakpoint) | |
| 5279 self.marginMenuActs["EnableBreakpoint"].setEnabled( | |
| 5280 supportsDebugger and hasBreakpoint) | |
| 5281 if supportsDebugger: | |
| 5282 if self.markersAtLine(self.line) & (1 << self.dbreakpoint): | |
| 5283 self.marginMenuActs["EnableBreakpoint"].setText( | |
| 5284 self.tr('Enable breakpoint')) | |
| 5285 else: | |
| 5286 self.marginMenuActs["EnableBreakpoint"].setText( | |
| 5287 self.tr('Disable breakpoint')) | |
| 5288 | |
| 5289 if menu is self.bmMarginMenu: | |
| 5290 hasBookmarks = bool(self.bookmarks) | |
| 5425 | 5291 |
| 5426 if len(self.syntaxerrors): | 5292 self.marginMenuActs["NextBookmark"].setEnabled(hasBookmarks) |
| 5427 self.marginMenuActs["GotoSyntaxError"].setEnabled(True) | 5293 self.marginMenuActs["PreviousBookmark"].setEnabled(hasBookmarks) |
| 5428 self.marginMenuActs["ClearSyntaxError"].setEnabled(True) | 5294 self.marginMenuActs["ClearBookmark"].setEnabled(hasBookmarks) |
| 5429 if self.markersAtLine(self.line) & (1 << self.syntaxerror): | 5295 |
| 5296 if menu is self.foldMarginMenu: | |
| 5297 isFoldHeader = bool(self.SendScintilla( | |
| 5298 QsciScintilla.SCI_GETFOLDLEVEL, self.line) & | |
| 5299 QsciScintilla.SC_FOLDLEVELHEADERFLAG) | |
| 5300 | |
| 5301 self.marginMenuActs["ExpandChildren"].setEnabled(isFoldHeader) | |
| 5302 self.marginMenuActs["CollapseChildren"].setEnabled(isFoldHeader) | |
| 5303 | |
| 5304 if menu is self.indicMarginMenu: | |
| 5305 hasSyntaxErrors = bool(self.syntaxerrors) | |
| 5306 hasWarnings = bool(self.warnings) | |
| 5307 hasNotCoveredMarkers = bool(self.notcoveredMarkers) | |
| 5308 | |
| 5309 self.marginMenuActs["GotoSyntaxError"].setEnabled(hasSyntaxErrors) | |
| 5310 self.marginMenuActs["ClearSyntaxError"].setEnabled(hasSyntaxErrors) | |
| 5311 if hasSyntaxErrors and \ | |
| 5312 self.markersAtLine(self.line) & (1 << self.syntaxerror): | |
| 5430 self.marginMenuActs["ShowSyntaxError"].setEnabled(True) | 5313 self.marginMenuActs["ShowSyntaxError"].setEnabled(True) |
| 5431 else: | 5314 else: |
| 5432 self.marginMenuActs["ShowSyntaxError"].setEnabled(False) | 5315 self.marginMenuActs["ShowSyntaxError"].setEnabled(False) |
| 5433 else: | 5316 |
| 5434 self.marginMenuActs["GotoSyntaxError"].setEnabled(False) | 5317 self.marginMenuActs["NextWarningMarker"].setEnabled(hasWarnings) |
| 5435 self.marginMenuActs["ClearSyntaxError"].setEnabled(False) | 5318 self.marginMenuActs["PreviousWarningMarker"].setEnabled( |
| 5436 self.marginMenuActs["ShowSyntaxError"].setEnabled(False) | 5319 hasWarnings) |
| 5437 | 5320 self.marginMenuActs["ClearWarnings"].setEnabled(hasWarnings) |
| 5438 if len(self.warnings): | 5321 if hasWarnings and \ |
| 5439 self.marginMenuActs["NextWarningMarker"].setEnabled(True) | 5322 self.markersAtLine(self.line) & (1 << self.warning): |
| 5440 self.marginMenuActs["PreviousWarningMarker"].setEnabled(True) | |
| 5441 self.marginMenuActs["ClearWarnings"].setEnabled(True) | |
| 5442 if self.markersAtLine(self.line) & (1 << self.warning): | |
| 5443 self.marginMenuActs["ShowWarning"].setEnabled(True) | 5323 self.marginMenuActs["ShowWarning"].setEnabled(True) |
| 5444 else: | 5324 else: |
| 5445 self.marginMenuActs["ShowWarning"].setEnabled(False) | 5325 self.marginMenuActs["ShowWarning"].setEnabled(False) |
| 5446 else: | |
| 5447 self.marginMenuActs["NextWarningMarker"].setEnabled(False) | |
| 5448 self.marginMenuActs["PreviousWarningMarker"].setEnabled(False) | |
| 5449 self.marginMenuActs["ClearWarnings"].setEnabled(False) | |
| 5450 self.marginMenuActs["ShowWarning"].setEnabled(False) | |
| 5451 | |
| 5452 if self.notcoveredMarkers: | |
| 5453 self.marginMenuActs["NextCoverageMarker"].setEnabled(True) | |
| 5454 self.marginMenuActs["PreviousCoverageMarker"].setEnabled(True) | |
| 5455 else: | |
| 5456 self.marginMenuActs["NextCoverageMarker"].setEnabled(False) | |
| 5457 self.marginMenuActs["PreviousCoverageMarker"].setEnabled(False) | |
| 5458 | |
| 5459 if self.__hasTaskMarkers: | |
| 5460 self.marginMenuActs["PreviousTaskMarker"].setEnabled(True) | |
| 5461 self.marginMenuActs["NextTaskMarker"].setEnabled(True) | |
| 5462 else: | |
| 5463 self.marginMenuActs["PreviousTaskMarker"].setEnabled(False) | |
| 5464 self.marginMenuActs["NextTaskMarker"].setEnabled(False) | |
| 5465 | |
| 5466 if self.__hasChangeMarkers: | |
| 5467 self.marginMenuActs["PreviousChangeMarker"].setEnabled(True) | |
| 5468 self.marginMenuActs["NextChangeMarker"].setEnabled(True) | |
| 5469 self.marginMenuActs["ClearChangeMarkers"].setEnabled(True) | |
| 5470 | 5326 |
| 5471 else: | 5327 self.marginMenuActs["NextCoverageMarker"].setEnabled( |
| 5472 self.marginMenuActs["PreviousChangeMarker"].setEnabled(False) | 5328 hasNotCoveredMarkers) |
| 5473 self.marginMenuActs["NextChangeMarker"].setEnabled(False) | 5329 self.marginMenuActs["PreviousCoverageMarker"].setEnabled( |
| 5474 self.marginMenuActs["ClearChangeMarkers"].setEnabled(False) | 5330 hasNotCoveredMarkers) |
| 5331 | |
| 5332 self.marginMenuActs["PreviousTaskMarker"].setEnabled( | |
| 5333 self.__hasTaskMarkers) | |
| 5334 self.marginMenuActs["NextTaskMarker"].setEnabled( | |
| 5335 self.__hasTaskMarkers) | |
| 5336 | |
| 5337 self.marginMenuActs["PreviousChangeMarker"].setEnabled( | |
| 5338 self.__hasChangeMarkers) | |
| 5339 self.marginMenuActs["NextChangeMarker"].setEnabled( | |
| 5340 self.__hasChangeMarkers) | |
| 5341 self.marginMenuActs["ClearChangeMarkers"].setEnabled( | |
| 5342 self.__hasChangeMarkers) | |
| 5475 | 5343 |
| 5476 self.showMenu.emit("Margin", menu, self) | 5344 self.showMenu.emit("Margin", menu, self) |
| 5477 | 5345 |
| 5478 def __showContextMenuChecks(self): | 5346 def __showContextMenuChecks(self): |
| 5479 """ | 5347 """ |
| 5754 if os.path.isfile(f): | 5622 if os.path.isfile(f): |
| 5755 files.append(f) | 5623 files.append(f) |
| 5756 if os.path.isfile(tf): | 5624 if os.path.isfile(tf): |
| 5757 files.append(tf) | 5625 files.append(tf) |
| 5758 | 5626 |
| 5759 # now check, if there are coverage files belonging to ourself | 5627 # now check, if there are coverage files belonging to ourselves |
| 5760 fn = self.getFileName() | 5628 fn = self.getFileName() |
| 5761 if fn is not None: | 5629 if fn is not None: |
| 5762 tfn = Utilities.getTestFileName(fn) | 5630 tfn = Utilities.getTestFileName(fn) |
| 5763 basename = os.path.splitext(fn)[0] | 5631 basename = os.path.splitext(fn)[0] |
| 5764 tbasename = os.path.splitext(tfn)[0] | 5632 tbasename = os.path.splitext(tfn)[0] |
| 5932 if os.path.isfile(f): | 5800 if os.path.isfile(f): |
| 5933 files.append(f) | 5801 files.append(f) |
| 5934 if os.path.isfile(tf): | 5802 if os.path.isfile(tf): |
| 5935 files.append(tf) | 5803 files.append(tf) |
| 5936 | 5804 |
| 5937 # now check, if there are profile files belonging to ourself | 5805 # now check, if there are profile files belonging to ourselves |
| 5938 fn = self.getFileName() | 5806 fn = self.getFileName() |
| 5939 if fn is not None: | 5807 if fn is not None: |
| 5940 tfn = Utilities.getTestFileName(fn) | 5808 tfn = Utilities.getTestFileName(fn) |
| 5941 basename = os.path.splitext(fn)[0] | 5809 basename = os.path.splitext(fn)[0] |
| 5942 tbasename = os.path.splitext(tfn)[0] | 5810 tbasename = os.path.splitext(tfn)[0] |
| 6431 self.clearAnnotations() | 6299 self.clearAnnotations() |
| 6432 for handle in list(self.warnings.keys()) + \ | 6300 for handle in list(self.warnings.keys()) + \ |
| 6433 list(self.syntaxerrors.keys()): | 6301 list(self.syntaxerrors.keys()): |
| 6434 line = self.markerLine(handle) | 6302 line = self.markerLine(handle) |
| 6435 self.__setAnnotation(line) | 6303 self.__setAnnotation(line) |
| 6304 | |
| 6305 ################################################################# | |
| 6306 ## Fold handling methods | |
| 6307 ################################################################# | |
| 6308 | |
| 6309 def toggleCurrentFold(self): | |
| 6310 """ | |
| 6311 Public slot to toggle the fold containing the current line. | |
| 6312 """ | |
| 6313 line, index = self.getCursorPosition() | |
| 6314 self.foldLine(line) | |
| 6315 | |
| 6316 def expandFoldWithChildren(self, line=-1): | |
| 6317 """ | |
| 6318 Public slot to expand the current fold including its children. | |
| 6319 | |
| 6320 @param line number of line to be expanded | |
| 6321 @type int | |
| 6322 """ | |
| 6323 if line == -1: | |
| 6324 line, index = self.getCursorPosition() | |
| 6325 | |
| 6326 self.SendScintilla(QsciScintilla.SCI_FOLDCHILDREN, line, | |
| 6327 QsciScintilla.SC_FOLDACTION_EXPAND) | |
| 6328 | |
| 6329 def collapseFoldWithChildren(self, line=-1): | |
| 6330 """ | |
| 6331 Public slot to collapse the current fold including its children. | |
| 6332 | |
| 6333 @param line number of line to be expanded | |
| 6334 @type int | |
| 6335 """ | |
| 6336 if line == -1: | |
| 6337 line, index = self.getCursorPosition() | |
| 6338 | |
| 6339 self.SendScintilla(QsciScintilla.SCI_FOLDCHILDREN, line, | |
| 6340 QsciScintilla.SC_FOLDACTION_CONTRACT) | |
| 6341 | |
| 6342 def __contextMenuExpandFoldWithChildren(self): | |
| 6343 """ | |
| 6344 Private slot to handle the context menu expand with children action. | |
| 6345 """ | |
| 6346 self.expandFoldWithChildren(self.line) | |
| 6347 | |
| 6348 def __contextMenuCollapseFoldWithChildren(self): | |
| 6349 """ | |
| 6350 Private slot to handle the context menu collapse with children action. | |
| 6351 """ | |
| 6352 self.collapseFoldWithChildren(self.line) | |
| 6436 | 6353 |
| 6437 ################################################################# | 6354 ################################################################# |
| 6438 ## Macro handling methods | 6355 ## Macro handling methods |
| 6439 ################################################################# | 6356 ################################################################# |
| 6440 | 6357 |
