QScintilla/Editor.py

changeset 6299
feb3cf2cbde3
parent 6297
85e20e9b4d55
child 6305
7652b925c25e
--- a/QScintilla/Editor.py	Sat May 19 16:41:22 2018 +0200
+++ b/QScintilla/Editor.py	Sat May 19 17:56:11 2018 +0200
@@ -29,7 +29,7 @@
 from E5Gui import E5FileDialog, E5MessageBox
 from E5Utilities.E5Cache import E5Cache
 
-from .QsciScintillaCompat import QsciScintillaCompat, QSCINTILLA_VERSION
+from .QsciScintillaCompat import QsciScintillaCompat
 from .EditorMarkerMap import EditorMarkerMap
 
 import Preferences
@@ -273,12 +273,6 @@
         self.cursorPositionChanged.connect(self.__cursorPositionChanged)
         self.modificationAttempted.connect(self.__modificationReadOnly)
         
-        # margins layout
-        if QSCINTILLA_VERSION() >= 0x020301:
-            self.__unifiedMargins = Preferences.getEditor("UnifiedMargins")
-        else:
-            self.__unifiedMargins = True
-        
         # define the margins markers
         self.__changeMarkerSaved = self.markerDefine(
             self.__createChangeMarkerPixmap(
@@ -1149,16 +1143,6 @@
         """
         self.marginMenuActs = {}
         
-        if self.__unifiedMargins:
-            self.__initContextMenuUnifiedMargins()
-        else:
-            self.__initContextMenuSeparateMargins()
-        
-    def __initContextMenuSeparateMargins(self):
-        """
-        Private method used to setup the context menu for the separated
-        margins.
-        """
         # bookmark margin
         self.bmMarginMenu = QMenu()
         
@@ -1172,7 +1156,7 @@
             self.tr('Clear all bookmarks'), self.clearBookmarks)
         
         self.bmMarginMenu.aboutToShow.connect(
-            lambda: self.__showContextMenuMargin(self.bmMarginMenu, False))
+            lambda: self.__showContextMenuMargin(self.bmMarginMenu))
         
         # breakpoint margin
         self.bpMarginMenu = QMenu()
@@ -1197,7 +1181,7 @@
             self.tr('Clear all breakpoints'), self.__menuClearBreakpoints)
         
         self.bpMarginMenu.aboutToShow.connect(
-            lambda: self.__showContextMenuMargin(self.bpMarginMenu, False))
+            lambda: self.__showContextMenuMargin(self.bpMarginMenu))
         
         # fold margin
         self.foldMarginMenu = QMenu()
@@ -1230,7 +1214,7 @@
                 self.clearFolds)
         
         self.foldMarginMenu.aboutToShow.connect(
-            lambda: self.__showContextMenuMargin(self.foldMarginMenu, False))
+            lambda: self.__showContextMenuMargin(self.foldMarginMenu))
         
         # indicator margin
         self.indicMarginMenu = QMenu()
@@ -1284,88 +1268,7 @@
                 self.tr('Clear changes'), self.__reinitOnlineChangeTrace)
         
         self.indicMarginMenu.aboutToShow.connect(
-            lambda: self.__showContextMenuMargin(self.indicMarginMenu, False))
-        
-    def __initContextMenuUnifiedMargins(self):
-        """
-        Private method used to setup the context menu for the unified margins.
-        """
-        self.marginMenu = QMenu()
-        
-        self.marginMenu.addAction(
-            self.tr('Toggle bookmark'), self.menuToggleBookmark)
-        self.marginMenuActs["NextBookmark"] = self.marginMenu.addAction(
-            self.tr('Next bookmark'), self.nextBookmark)
-        self.marginMenuActs["PreviousBookmark"] = self.marginMenu.addAction(
-            self.tr('Previous bookmark'), self.previousBookmark)
-        self.marginMenuActs["ClearBookmark"] = self.marginMenu.addAction(
-            self.tr('Clear all bookmarks'), self.clearBookmarks)
-        self.marginMenu.addSeparator()
-        self.marginMenuActs["GotoSyntaxError"] = self.marginMenu.addAction(
-            self.tr('Goto syntax error'), self.gotoSyntaxError)
-        self.marginMenuActs["ShowSyntaxError"] = self.marginMenu.addAction(
-            self.tr('Show syntax error message'), self.__showSyntaxError)
-        self.marginMenuActs["ClearSyntaxError"] = self.marginMenu.addAction(
-            self.tr('Clear syntax error'), self.clearSyntaxError)
-        self.marginMenu.addSeparator()
-        self.marginMenuActs["NextWarningMarker"] = self.marginMenu.addAction(
-            self.tr("Next warning"), self.nextWarning)
-        self.marginMenuActs["PreviousWarningMarker"] = \
-            self.marginMenu.addAction(
-                self.tr("Previous warning"), self.previousWarning)
-        self.marginMenuActs["ShowWarning"] = self.marginMenu.addAction(
-            self.tr('Show warning message'), self.__showWarning)
-        self.marginMenuActs["ClearWarnings"] = self.marginMenu.addAction(
-            self.tr('Clear warnings'), self.clearWarnings)
-        self.marginMenu.addSeparator()
-        self.marginMenuActs["Breakpoint"] = self.marginMenu.addAction(
-            self.tr('Toggle breakpoint'), self.menuToggleBreakpoint)
-        self.marginMenuActs["TempBreakpoint"] = self.marginMenu.addAction(
-            self.tr('Toggle temporary breakpoint'),
-            self.__menuToggleTemporaryBreakpoint)
-        self.marginMenuActs["EditBreakpoint"] = self.marginMenu.addAction(
-            self.tr('Edit breakpoint...'), self.menuEditBreakpoint)
-        self.marginMenuActs["EnableBreakpoint"] = self.marginMenu.addAction(
-            self.tr('Enable breakpoint'),
-            self.__menuToggleBreakpointEnabled)
-        self.marginMenuActs["NextBreakpoint"] = self.marginMenu.addAction(
-            self.tr('Next breakpoint'), self.menuNextBreakpoint)
-        self.marginMenuActs["PreviousBreakpoint"] = self.marginMenu.addAction(
-            self.tr('Previous breakpoint'), self.menuPreviousBreakpoint)
-        self.marginMenuActs["ClearBreakpoint"] = self.marginMenu.addAction(
-            self.tr('Clear all breakpoints'), self.__menuClearBreakpoints)
-        self.marginMenu.addSeparator()
-        self.marginMenuActs["NextCoverageMarker"] = self.marginMenu.addAction(
-            self.tr('Next uncovered line'), self.nextUncovered)
-        self.marginMenuActs["PreviousCoverageMarker"] = \
-            self.marginMenu.addAction(
-                self.tr('Previous uncovered line'), self.previousUncovered)
-        self.marginMenu.addSeparator()
-        self.marginMenuActs["NextTaskMarker"] = self.marginMenu.addAction(
-            self.tr('Next task'), self.nextTask)
-        self.marginMenuActs["PreviousTaskMarker"] = self.marginMenu.addAction(
-            self.tr('Previous task'), self.previousTask)
-        self.marginMenu.addSeparator()
-        self.marginMenuActs["NextChangeMarker"] = self.marginMenu.addAction(
-            self.tr('Next change'), self.nextChange)
-        self.marginMenuActs["PreviousChangeMarker"] = \
-            self.marginMenu.addAction(
-                self.tr('Previous change'), self.previousChange)
-        self.marginMenuActs["ClearChangeMarkers"] = \
-            self.marginMenu.addAction(
-                self.tr('Clear changes'), self.__reinitOnlineChangeTrace)
-        self.marginMenu.addSeparator()
-        self.marginMenuActs["LMBbookmarks"] = self.marginMenu.addAction(
-            self.tr('LMB toggles bookmarks'), self.__lmBbookmarks)
-        self.marginMenuActs["LMBbookmarks"].setCheckable(True)
-        self.marginMenuActs["LMBbookmarks"].setChecked(False)
-        self.marginMenuActs["LMBbreakpoints"] = self.marginMenu.addAction(
-            self.tr('LMB toggles breakpoints'), self.__lmBbreakpoints)
-        self.marginMenuActs["LMBbreakpoints"].setCheckable(True)
-        self.marginMenuActs["LMBbreakpoints"].setChecked(True)
-        
-        self.marginMenu.aboutToShow.connect(
-            lambda: self.__showContextMenuMargin(self.marginMenu, True))
+            lambda: self.__showContextMenuMargin(self.indicMarginMenu))
         
     def __exportMenuTriggered(self, act):
         """
@@ -2391,6 +2294,7 @@
                     self.breakpointModel.setBreakPointByIndex(
                         index, self.fileName, ln,
                         (cond, temp, enabled, ignorecount))
+                    break
         
         self.line = -1
         
@@ -3385,33 +3289,15 @@
         @param line line number of the click (integer)
         @param modifiers keyboard modifiers (Qt.KeyboardModifiers)
         """
-        if self.__unifiedMargins:
-            if margin == 1:
-                if modifiers & Qt.KeyboardModifiers(Qt.ShiftModifier):
-                    if self.marginMenuActs["LMBbreakpoints"].isChecked():
-                        self.toggleBookmark(line + 1)
-                    else:
-                        self.__toggleBreakpoint(line + 1)
-                elif modifiers & Qt.KeyboardModifiers(Qt.ControlModifier):
-                    if self.markersAtLine(line) & (1 << self.syntaxerror):
-                        self.__showSyntaxError(line)
-                    elif self.markersAtLine(line) & (1 << self.warning):
-                        self.__showWarning(line)
-                else:
-                    if self.marginMenuActs["LMBbreakpoints"].isChecked():
-                        self.__toggleBreakpoint(line + 1)
-                    else:
-                        self.toggleBookmark(line + 1)
-        else:
-            if margin == self.__bmMargin:
-                        self.toggleBookmark(line + 1)
-            elif margin == self.__bpMargin:
-                        self.__toggleBreakpoint(line + 1)
-            elif margin == self.__indicMargin:
-                if self.markersAtLine(line) & (1 << self.syntaxerror):
-                    self.__showSyntaxError(line)
-                elif self.markersAtLine(line) & (1 << self.warning):
-                    self.__showWarning(line)
+        if margin == self.__bmMargin:
+                    self.toggleBookmark(line + 1)
+        elif margin == self.__bpMargin:
+                    self.__toggleBreakpoint(line + 1)
+        elif margin == self.__indicMargin:
+            if self.markersAtLine(line) & (1 << self.syntaxerror):
+                self.__showSyntaxError(line)
+            elif self.markersAtLine(line) & (1 << self.warning):
+                self.__showWarning(line)
         
     def handleMonospacedEnable(self):
         """
@@ -4194,10 +4080,6 @@
         if self.completer is not None:
             self.completer.readSettings()
         
-        # set the margins layout
-        if QSCINTILLA_VERSION() >= 0x020301:
-            self.__unifiedMargins = Preferences.getEditor("UnifiedMargins")
-        
         # set the line marker colours or pixmap
         if Preferences.getEditor("LineMarkersBackground"):
             self.markerDefine(QsciScintilla.Background, self.currentline)
@@ -4313,60 +4195,37 @@
             self.setMarginSensitivity(margin, False)
         
         # set marker margin(s) settings
-        if self.__unifiedMargins:
-            margin1Mask = (1 << self.breakpoint) | \
-                          (1 << self.cbreakpoint) | \
-                          (1 << self.tbreakpoint) | \
-                          (1 << self.tcbreakpoint) | \
-                          (1 << self.dbreakpoint) | \
-                          (1 << self.currentline) | \
-                          (1 << self.errorline) | \
-                          (1 << self.bookmark) | \
-                          (1 << self.syntaxerror) | \
+        self.__bmMargin = 0
+        self.__linenoMargin = 1
+        self.__bpMargin = 2
+        self.__foldMargin = 3
+        self.__indicMargin = 4
+        
+        marginBmMask = (1 << self.bookmark)
+        self.setMarginWidth(self.__bmMargin, 16)
+        self.setMarginSensitivity(self.__bmMargin, True)
+        self.setMarginMarkerMask(self.__bmMargin, marginBmMask)
+        
+        marginBpMask = (1 << self.breakpoint) | \
+                       (1 << self.cbreakpoint) | \
+                       (1 << self.tbreakpoint) | \
+                       (1 << self.tcbreakpoint) | \
+                       (1 << self.dbreakpoint)
+        self.setMarginWidth(self.__bpMargin, 16)
+        self.setMarginSensitivity(self.__bpMargin, True)
+        self.setMarginMarkerMask(self.__bpMargin, marginBpMask)
+        
+        marginIndicMask = (1 << self.syntaxerror) | \
                           (1 << self.notcovered) | \
                           (1 << self.taskmarker) | \
                           (1 << self.warning) | \
                           (1 << self.__changeMarkerUnsaved) | \
-                          (1 << self.__changeMarkerSaved)
-            self.setMarginWidth(1, 16)
-            self.setMarginSensitivity(1, True)
-            self.setMarginMarkerMask(1, margin1Mask)
-            
-            self.__linenoMargin = 0
-            self.__foldMargin = 2
-        else:
-            
-            self.__bmMargin = 0
-            self.__linenoMargin = 1
-            self.__bpMargin = 2
-            self.__foldMargin = 3
-            self.__indicMargin = 4
-            
-            marginBmMask = (1 << self.bookmark)
-            self.setMarginWidth(self.__bmMargin, 16)
-            self.setMarginSensitivity(self.__bmMargin, True)
-            self.setMarginMarkerMask(self.__bmMargin, marginBmMask)
-            
-            marginBpMask = (1 << self.breakpoint) | \
-                           (1 << self.cbreakpoint) | \
-                           (1 << self.tbreakpoint) | \
-                           (1 << self.tcbreakpoint) | \
-                           (1 << self.dbreakpoint)
-            self.setMarginWidth(self.__bpMargin, 16)
-            self.setMarginSensitivity(self.__bpMargin, True)
-            self.setMarginMarkerMask(self.__bpMargin, marginBpMask)
-            
-            marginIndicMask = (1 << self.syntaxerror) | \
-                              (1 << self.notcovered) | \
-                              (1 << self.taskmarker) | \
-                              (1 << self.warning) | \
-                              (1 << self.__changeMarkerUnsaved) | \
-                              (1 << self.__changeMarkerSaved) | \
-                              (1 << self.currentline) | \
-                              (1 << self.errorline)
-            self.setMarginWidth(self.__indicMargin, 16)
-            self.setMarginSensitivity(self.__indicMargin, True)
-            self.setMarginMarkerMask(self.__indicMargin, marginIndicMask)
+                          (1 << self.__changeMarkerSaved) | \
+                          (1 << self.currentline) | \
+                          (1 << self.errorline)
+        self.setMarginWidth(self.__indicMargin, 16)
+        self.setMarginSensitivity(self.__indicMargin, True)
+        self.setMarginMarkerMask(self.__indicMargin, marginIndicMask)
         
         # set linenumber margin settings
         linenoMargin = Preferences.getEditor("LinenoMargin")
@@ -5257,18 +5116,15 @@
                 self.menu.popup(evt.globalPos())
         else:
             self.line = self.lineAt(evt.pos())
-            if self.__unifiedMargins:
-                self.marginMenu.popup(evt.globalPos())
-            else:
-                if self.__marginNumber(evt.x()) in [self.__bmMargin,
-                                                    self.__linenoMargin]:
-                    self.bmMarginMenu.popup(evt.globalPos())
-                elif self.__marginNumber(evt.x()) == self.__bpMargin:
-                    self.bpMarginMenu.popup(evt.globalPos())
-                elif self.__marginNumber(evt.x()) == self.__indicMargin:
-                    self.indicMarginMenu.popup(evt.globalPos())
-                elif self.__marginNumber(evt.x()) == self.__foldMargin:
-                    self.foldMarginMenu.popup(evt.globalPos())
+            if self.__marginNumber(evt.x()) in [self.__bmMargin,
+                                                self.__linenoMargin]:
+                self.bmMarginMenu.popup(evt.globalPos())
+            elif self.__marginNumber(evt.x()) == self.__bpMargin:
+                self.bpMarginMenu.popup(evt.globalPos())
+            elif self.__marginNumber(evt.x()) == self.__indicMargin:
+                self.indicMarginMenu.popup(evt.globalPos())
+            elif self.__marginNumber(evt.x()) == self.__foldMargin:
+                self.foldMarginMenu.popup(evt.globalPos())
         
     def __showContextMenu(self):
         """
@@ -5430,109 +5286,94 @@
         
         self.showMenu.emit("Graphics", self.graphicsMenu, self)
         
-    def __showContextMenuMargin(self, menu, unifiedMenu):
+    def __showContextMenuMargin(self, menu):
         """
         Private slot handling the aboutToShow signal of the margins context
         menu.
         
         @param menu reference to the menu to be shown
         @type QMenu
-        @param unifiedMenu flag indicating the unified margins menu
-        @type bool
-        """
-        if unifiedMenu or menu is self.bpMarginMenu:
-            if self.fileName and self.isPyFile():
-                self.marginMenuActs["Breakpoint"].setEnabled(True)
-                self.marginMenuActs["TempBreakpoint"].setEnabled(True)
-                if self.markersAtLine(self.line) & self.breakpointMask:
-                    self.marginMenuActs["EditBreakpoint"].setEnabled(True)
-                    self.marginMenuActs["EnableBreakpoint"].setEnabled(True)
-                else:
-                    self.marginMenuActs["EditBreakpoint"].setEnabled(False)
-                    self.marginMenuActs["EnableBreakpoint"].setEnabled(False)
+        """
+        if menu is self.bpMarginMenu:
+            supportsDebugger = bool(self.fileName and self.isPyFile())
+            hasBreakpoints = bool(self.breaks)
+            hasBreakpoint = bool(
+                self.markersAtLine(self.line) & self.breakpointMask)
+            
+            self.marginMenuActs["Breakpoint"].setEnabled(supportsDebugger)
+            self.marginMenuActs["TempBreakpoint"].setEnabled(supportsDebugger)
+            self.marginMenuActs["NextBreakpoint"].setEnabled(
+                supportsDebugger and hasBreakpoints)
+            self.marginMenuActs["PreviousBreakpoint"].setEnabled(
+                supportsDebugger and hasBreakpoints)
+            self.marginMenuActs["ClearBreakpoint"].setEnabled(
+                supportsDebugger and hasBreakpoints)
+            self.marginMenuActs["EditBreakpoint"].setEnabled(
+                supportsDebugger and hasBreakpoint)
+            self.marginMenuActs["EnableBreakpoint"].setEnabled(
+                supportsDebugger and hasBreakpoint)
+            if supportsDebugger:
                 if self.markersAtLine(self.line) & (1 << self.dbreakpoint):
                     self.marginMenuActs["EnableBreakpoint"].setText(
                         self.tr('Enable breakpoint'))
                 else:
                     self.marginMenuActs["EnableBreakpoint"].setText(
                         self.tr('Disable breakpoint'))
-                if self.breaks:
-                    self.marginMenuActs["NextBreakpoint"].setEnabled(True)
-                    self.marginMenuActs["PreviousBreakpoint"].setEnabled(True)
-                    self.marginMenuActs["ClearBreakpoint"].setEnabled(True)
-                else:
-                    self.marginMenuActs["NextBreakpoint"].setEnabled(False)
-                    self.marginMenuActs["PreviousBreakpoint"].setEnabled(False)
-                    self.marginMenuActs["ClearBreakpoint"].setEnabled(False)
-            else:
-                self.marginMenuActs["Breakpoint"].setEnabled(False)
-                self.marginMenuActs["TempBreakpoint"].setEnabled(False)
-                self.marginMenuActs["EditBreakpoint"].setEnabled(False)
-                self.marginMenuActs["EnableBreakpoint"].setEnabled(False)
-                self.marginMenuActs["NextBreakpoint"].setEnabled(False)
-                self.marginMenuActs["PreviousBreakpoint"].setEnabled(False)
-                self.marginMenuActs["ClearBreakpoint"].setEnabled(False)
+        
+        if menu is self.bmMarginMenu:
+            hasBookmarks = bool(self.bookmarks)
+            
+            self.marginMenuActs["NextBookmark"].setEnabled(hasBookmarks)
+            self.marginMenuActs["PreviousBookmark"].setEnabled(hasBookmarks)
+            self.marginMenuActs["ClearBookmark"].setEnabled(hasBookmarks)
+        
+        if menu is self.foldMarginMenu:
+            isFoldHeader = bool(self.SendScintilla(
+                QsciScintilla.SCI_GETFOLDLEVEL, self.line) &
+                QsciScintilla.SC_FOLDLEVELHEADERFLAG)
             
-        if unifiedMenu or menu is self.bmMarginMenu:
-            if self.bookmarks:
-                self.marginMenuActs["NextBookmark"].setEnabled(True)
-                self.marginMenuActs["PreviousBookmark"].setEnabled(True)
-                self.marginMenuActs["ClearBookmark"].setEnabled(True)
-            else:
-                self.marginMenuActs["NextBookmark"].setEnabled(False)
-                self.marginMenuActs["PreviousBookmark"].setEnabled(False)
-                self.marginMenuActs["ClearBookmark"].setEnabled(False)
+            self.marginMenuActs["ExpandChildren"].setEnabled(isFoldHeader)
+            self.marginMenuActs["CollapseChildren"].setEnabled(isFoldHeader)
+        
+        if menu is self.indicMarginMenu:
+            hasSyntaxErrors = bool(self.syntaxerrors)
+            hasWarnings = bool(self.warnings)
+            hasNotCoveredMarkers = bool(self.notcoveredMarkers)
             
-        if unifiedMenu or menu is self.indicMarginMenu:
-            if len(self.syntaxerrors):
-                self.marginMenuActs["GotoSyntaxError"].setEnabled(True)
-                self.marginMenuActs["ClearSyntaxError"].setEnabled(True)
-                if self.markersAtLine(self.line) & (1 << self.syntaxerror):
-                    self.marginMenuActs["ShowSyntaxError"].setEnabled(True)
-                else:
-                    self.marginMenuActs["ShowSyntaxError"].setEnabled(False)
+            self.marginMenuActs["GotoSyntaxError"].setEnabled(hasSyntaxErrors)
+            self.marginMenuActs["ClearSyntaxError"].setEnabled(hasSyntaxErrors)
+            if hasSyntaxErrors and \
+               self.markersAtLine(self.line) & (1 << self.syntaxerror):
+                self.marginMenuActs["ShowSyntaxError"].setEnabled(True)
             else:
-                self.marginMenuActs["GotoSyntaxError"].setEnabled(False)
-                self.marginMenuActs["ClearSyntaxError"].setEnabled(False)
                 self.marginMenuActs["ShowSyntaxError"].setEnabled(False)
             
-            if len(self.warnings):
-                self.marginMenuActs["NextWarningMarker"].setEnabled(True)
-                self.marginMenuActs["PreviousWarningMarker"].setEnabled(True)
-                self.marginMenuActs["ClearWarnings"].setEnabled(True)
-                if self.markersAtLine(self.line) & (1 << self.warning):
-                    self.marginMenuActs["ShowWarning"].setEnabled(True)
-                else:
-                    self.marginMenuActs["ShowWarning"].setEnabled(False)
+            self.marginMenuActs["NextWarningMarker"].setEnabled(hasWarnings)
+            self.marginMenuActs["PreviousWarningMarker"].setEnabled(
+                hasWarnings)
+            self.marginMenuActs["ClearWarnings"].setEnabled(hasWarnings)
+            if hasWarnings and \
+               self.markersAtLine(self.line) & (1 << self.warning):
+                self.marginMenuActs["ShowWarning"].setEnabled(True)
             else:
-                self.marginMenuActs["NextWarningMarker"].setEnabled(False)
-                self.marginMenuActs["PreviousWarningMarker"].setEnabled(False)
-                self.marginMenuActs["ClearWarnings"].setEnabled(False)
                 self.marginMenuActs["ShowWarning"].setEnabled(False)
             
-            if self.notcoveredMarkers:
-                self.marginMenuActs["NextCoverageMarker"].setEnabled(True)
-                self.marginMenuActs["PreviousCoverageMarker"].setEnabled(True)
-            else:
-                self.marginMenuActs["NextCoverageMarker"].setEnabled(False)
-                self.marginMenuActs["PreviousCoverageMarker"].setEnabled(False)
+            self.marginMenuActs["NextCoverageMarker"].setEnabled(
+                hasNotCoveredMarkers)
+            self.marginMenuActs["PreviousCoverageMarker"].setEnabled(
+                hasNotCoveredMarkers)
             
-            if self.__hasTaskMarkers:
-                self.marginMenuActs["PreviousTaskMarker"].setEnabled(True)
-                self.marginMenuActs["NextTaskMarker"].setEnabled(True)
-            else:
-                self.marginMenuActs["PreviousTaskMarker"].setEnabled(False)
-                self.marginMenuActs["NextTaskMarker"].setEnabled(False)
+            self.marginMenuActs["PreviousTaskMarker"].setEnabled(
+                self.__hasTaskMarkers)
+            self.marginMenuActs["NextTaskMarker"].setEnabled(
+                self.__hasTaskMarkers)
             
-            if self.__hasChangeMarkers:
-                self.marginMenuActs["PreviousChangeMarker"].setEnabled(True)
-                self.marginMenuActs["NextChangeMarker"].setEnabled(True)
-                self.marginMenuActs["ClearChangeMarkers"].setEnabled(True)
-                
-            else:
-                self.marginMenuActs["PreviousChangeMarker"].setEnabled(False)
-                self.marginMenuActs["NextChangeMarker"].setEnabled(False)
-                self.marginMenuActs["ClearChangeMarkers"].setEnabled(False)
+            self.marginMenuActs["PreviousChangeMarker"].setEnabled(
+                self.__hasChangeMarkers)
+            self.marginMenuActs["NextChangeMarker"].setEnabled(
+                self.__hasChangeMarkers)
+            self.marginMenuActs["ClearChangeMarkers"].setEnabled(
+                self.__hasChangeMarkers)
         
         self.showMenu.emit("Margin", menu, self)
         

eric ide

mercurial