Mercurial Repositories > eric / file comparison
comparison: QScintilla/Lexers/SubstyledLexer.py
QScintilla/Lexers/SubstyledLexer.py
- branch
- sub_styles
- changeset 6856
- cdf13841603c
- parent 6855
- 4d80c8cc99a1
- child 6859
- 951aa89d367d
equal
deleted
inserted
replaced
| 6855:4d80c8cc99a1 | 6856:cdf13841603c |
|---|---|
| 50 self.__subStyles = {} | 50 self.__subStyles = {} |
| 51 self.__subStylesInitialized = False | 51 self.__subStylesInitialized = False |
| 52 | 52 |
| 53 def loadSubstyles(self): | 53 def loadSubstyles(self): |
| 54 """ | 54 """ |
| 55 Public method to load the sub-styles from the settings file | 55 Public method to load the sub-styles from the settings file. |
| 56 """ | 56 """ |
| 57 settings = Preferences.Prefs.settings | 57 settings = Preferences.Prefs.settings |
| 58 | 58 |
| 59 self.loadDefaultSubStyles() | 59 # Step 1: check if sub-styles were defined and saved |
| 60 | 60 subStylesDefined = False |
| 61 for baseStyle in self.baseStyles: | 61 for baseStyle in self.baseStyles: |
| 62 key = "Scintilla/{0}/style{1}/SubStyleLength".format( | 62 key = "Scintilla/{0}/style{1}/SubStyleLength".format( |
| 63 self.language(), baseStyle) | 63 self.language(), baseStyle) |
| 64 if settings.contains(key): | 64 subStylesDefined |= settings.contains(key) |
| 65 subStyleLength = int(settings.value(key), 0) | 65 # Step 2.1: load default sub-styles, if none were defined |
| 66 self.__subStyles[baseStyle] = {} | 66 if not subStylesDefined: |
| 67 if subStyleLength: | 67 self.loadDefaultSubStyles() |
| 68 self.__subStyles[baseStyle] = [] | 68 |
| 69 for subStyle in range(subStyleLength): | 69 # Step 2.2: load from settings file |
| 70 baseKey = "Scintilla/{0}/style{1}/substyle{2}/".format( | 70 else: |
| 71 self.language(), baseStyle, subStyle) | 71 self.__subStyles = {} |
| 72 if settings.contains(baseKey): | 72 for baseStyle in self.baseStyles: |
| 73 subStyleData = {} | 73 key = "Scintilla/{0}/style{1}/SubStyleLength".format( |
| 74 subStyleData["Description"] = settings.value( | 74 self.language(), baseStyle) |
| 75 baseKey + "Description", "") | 75 if settings.contains(key): |
| 76 subStyleData["Words"] = settings.value( | 76 subStyleLength = int(settings.value(key), 0) |
| 77 baseKey + "Words", "") | 77 if subStyleLength: |
| 78 style = {} | 78 self.__subStyles[baseStyle] = {} |
| 79 | 79 for subStyle in range(subStyleLength): |
| 80 key = baseKey + "fore" | 80 substyleKey = \ |
| 81 if settings.contains(key): | 81 "Scintilla/{0}/style{1}/substyle{2}/"\ |
| 82 style["fore"] = int(settings.value(key)) | 82 .format(self.language(), baseStyle, subStyle) |
| 83 key = baseKey + "paper" | 83 if settings.contains(substyleKey): |
| 84 if settings.contains(key): | 84 subStyleData = {} |
| 85 style["paper"] = int(settings.value(key)) | 85 subStyleData["Description"] = settings.value( |
| 86 key = baseKey + "eolfill" | 86 substyleKey + "Description", "") |
| 87 if settings.contains(key): | 87 subStyleData["Words"] = settings.value( |
| 88 style["eolfill"] = Preferences.toBool( | 88 substyleKey + "Words", "") |
| 89 settings.value(key)) | 89 style = {} |
| 90 key = baseKey + "font_family" | 90 |
| 91 if settings.contains(key): | 91 key = substyleKey + "fore" |
| 92 style["font_family"] = settings.value(key) | 92 if settings.contains(key): |
| 93 key = baseKey + "font_size" | 93 style["fore"] = int(settings.value(key)) |
| 94 if settings.contains(key): | 94 key = substyleKey + "paper" |
| 95 style["font_size"] = int(settings.value(key)) | 95 if settings.contains(key): |
| 96 key = baseKey + "font_bold" | 96 style["paper"] = int(settings.value(key)) |
| 97 if settings.contains(key): | 97 key = substyleKey + "eolfill" |
| 98 style["font_bold"] = Preferences.toBool( | 98 if settings.contains(key): |
| 99 settings.value(key)) | 99 style["eolfill"] = Preferences.toBool( |
| 100 key = baseKey + "font_italic" | 100 settings.value(key)) |
| 101 if settings.contains(key): | 101 key = substyleKey + "font_family" |
| 102 style["font_italic"] = Preferences.toBool( | 102 if settings.contains(key): |
| 103 settings.value(key)) | 103 style["font_family"] = settings.value(key) |
| 104 key = baseKey + "font_underline" | 104 key = substyleKey + "font_size" |
| 105 if settings.contains(key): | 105 if settings.contains(key): |
| 106 style["font_underline"] = Preferences.toBool( | 106 style["font_size"] = \ |
| 107 settings.value(key)) | 107 int(settings.value(key)) |
| 108 | 108 key = substyleKey + "font_bold" |
| 109 subStyleData["Style"] = style | 109 if settings.contains(key): |
| 110 | 110 style["font_bold"] = Preferences.toBool( |
| 111 self.__subStyles[baseStyle][subStyle] = \ | 111 settings.value(key)) |
| 112 subStyleData | 112 key = substyleKey + "font_italic" |
| 113 if settings.contains(key): | |
| 114 style["font_italic"] = Preferences.toBool( | |
| 115 settings.value(key)) | |
| 116 key = substyleKey + "font_underline" | |
| 117 if settings.contains(key): | |
| 118 style["font_underline"] = \ | |
| 119 Preferences.toBool(settings.value(key)) | |
| 120 | |
| 121 subStyleData["Style"] = style | |
| 122 | |
| 123 self.__subStyles[baseStyle][subStyle] = \ | |
| 124 subStyleData | |
| 113 | 125 |
| 114 self.__subStylesInitialized = True | 126 self.__subStylesInitialized = True |
| 115 | 127 |
| 116 def loadDefaultSubStyles(self): | 128 def loadDefaultSubStyles(self): |
| 117 """ | 129 """ |
| 151 subStyleLength = len(subStylesData) | 163 subStyleLength = len(subStylesData) |
| 152 subStyleStart = editor.SendScintilla( | 164 subStyleStart = editor.SendScintilla( |
| 153 editor.SCI_ALLOCATESUBSTYLES, baseStyleNo, subStyleLength) | 165 editor.SCI_ALLOCATESUBSTYLES, baseStyleNo, subStyleLength) |
| 154 if subStyleStart < 0: | 166 if subStyleStart < 0: |
| 155 subStyleLength = 0 | 167 subStyleLength = 0 |
| 156 for subStyleIndex in range(subStyleLength): | 168 subStyleIndex = -1 |
| 169 for subStyleKey in sorted(subStylesData.keys()): | |
| 170 subStyleIndex += 1 | |
| 157 styleNo = subStyleStart + subStyleIndex | 171 styleNo = subStyleStart + subStyleIndex |
| 158 subStyle = subStylesData[subStyleIndex] | 172 subStyle = subStylesData[subStyleKey] |
| 159 # set the words | 173 # set the words |
| 160 editor.SendScintilla( | 174 editor.SendScintilla( |
| 161 editor.SCI_SETIDENTIFIERS, | 175 editor.SCI_SETIDENTIFIERS, |
| 162 styleNo, | 176 styleNo, |
| 163 subStyle["Words"].encode()) | 177 subStyle["Words"].encode()) |
| 206 def writeSubstyles(self): | 220 def writeSubstyles(self): |
| 207 """ | 221 """ |
| 208 Public method to save the sub-styles. | 222 Public method to save the sub-styles. |
| 209 """ | 223 """ |
| 210 if not self.__subStylesInitialized: | 224 if not self.__subStylesInitialized: |
| 211 # make sure, the sub-styles have been initialized | 225 return |
| 212 self.loadSubstyles() | |
| 213 | 226 |
| 214 settings = Preferences.Prefs.settings | 227 settings = Preferences.Prefs.settings |
| 215 | 228 |
| 229 # Step 1: remove all sub-style definitions first | |
| 230 for baseStyle in self.baseStyles: | |
| 231 key = "Scintilla/{0}/style{1}/SubStyleLength".format( | |
| 232 self.language(), baseStyle) | |
| 233 if settings.contains(key): | |
| 234 subStyleLength = int(settings.value(key), 0) | |
| 235 if subStyleLength: | |
| 236 self.__subStyles[baseStyle] = {} | |
| 237 for subStyle in range(subStyleLength): | |
| 238 substyleKey = "Scintilla/{0}/style{1}/substyle{2}/"\ | |
| 239 .format(self.language(), baseStyle, subStyle) | |
| 240 settings.remove(substyleKey) | |
| 241 | |
| 242 # Step 2: save the defined sub-styles | |
| 216 for baseStyle in self.baseStyles: | 243 for baseStyle in self.baseStyles: |
| 217 key = "Scintilla/{0}/style{1}/SubStyleLength".format( | 244 key = "Scintilla/{0}/style{1}/SubStyleLength".format( |
| 218 self.language(), baseStyle) | 245 self.language(), baseStyle) |
| 219 settings.setValue(key, len(self.__subStyles[baseStyle])) | 246 settings.setValue(key, len(self.__subStyles[baseStyle])) |
| 220 for subStyle in self.__subStyles[baseStyle]: | 247 for subStyle in self.__subStyles[baseStyle]: |
| 221 baseKey = "Scintilla/{0}/style{1}/substyle{2}/".format( | 248 substyleKey = "Scintilla/{0}/style{1}/substyle{2}/".format( |
| 222 self.language(), baseStyle, subStyle) | 249 self.language(), baseStyle, subStyle) |
| 223 subStyleData = self.__subStyles[baseStyle][subStyle] | 250 subStyleData = self.__subStyles[baseStyle][subStyle] |
| 224 | 251 |
| 225 settings.setValue(baseKey + "Description", | 252 if not subStyleData["Description"] and \ |
| 253 not subStyleData["Words"]: | |
| 254 # invalid or incomplete sub-style definition | |
| 255 continue | |
| 256 | |
| 257 settings.setValue(substyleKey + "Description", | |
| 226 subStyleData["Description"]) | 258 subStyleData["Description"]) |
| 227 settings.setValue(baseKey + "Words", | 259 settings.setValue(substyleKey + "Words", |
| 228 subStyleData["Words"]) | 260 subStyleData["Words"]) |
| 229 | 261 |
| 230 style = subStyleData["Style"] | 262 style = subStyleData["Style"] |
| 231 if "fore" in style: | 263 if "fore" in style: |
| 232 color = style["fore"] | 264 color = style["fore"] |
| 233 else: | 265 else: |
| 234 col = self.color(baseStyle) | 266 col = self.color(baseStyle) |
| 235 color = col.red() << 16 | col.green() << 8 | col.blue() | 267 color = col.red() << 16 | col.green() << 8 | col.blue() |
| 236 settings.setValue(baseKey + "fore", color) | 268 settings.setValue(substyleKey + "fore", color) |
| 237 if "paper" in style: | 269 if "paper" in style: |
| 238 color = style["paper"] | 270 color = style["paper"] |
| 239 else: | 271 else: |
| 240 col = self.paper(baseStyle) | 272 col = self.paper(baseStyle) |
| 241 color = col.red() << 16 | col.green() << 8 | col.blue() | 273 color = col.red() << 16 | col.green() << 8 | col.blue() |
| 242 settings.setValue(baseKey + "paper", color) | 274 settings.setValue(substyleKey + "paper", color) |
| 243 if "eolfill" in style: | 275 if "eolfill" in style: |
| 244 eolfill = style["eolfill"] | 276 eolfill = style["eolfill"] |
| 245 else: | 277 else: |
| 246 eolfill = self.eolFill(baseStyle) | 278 eolfill = self.eolFill(baseStyle) |
| 247 settings.setValue(baseKey + "eolfill", eolfill) | 279 settings.setValue(substyleKey + "eolfill", eolfill) |
| 248 font = self.font(baseStyle) | 280 font = self.font(baseStyle) |
| 249 if "font_family" in style: | 281 if "font_family" in style: |
| 250 family = style["font_family"] | 282 family = style["font_family"] |
| 251 else: | 283 else: |
| 252 family = font.family() | 284 family = font.family() |
| 253 settings.setValue(baseKey + "font_family", family) | 285 settings.setValue(substyleKey + "font_family", family) |
| 254 if "font_size" in style: | 286 if "font_size" in style: |
| 255 size = style["font_size"] | 287 size = style["font_size"] |
| 256 else: | 288 else: |
| 257 size = font.pointSize() | 289 size = font.pointSize() |
| 258 settings.setValue(baseKey + "font_size", size) | 290 settings.setValue(substyleKey + "font_size", size) |
| 259 if "font_bold" in style: | 291 if "font_bold" in style: |
| 260 bold = style["font_bold"] | 292 bold = style["font_bold"] |
| 261 else: | 293 else: |
| 262 bold = font.bold() | 294 bold = font.bold() |
| 263 settings.setValue(baseKey + "font_bold", bold) | 295 settings.setValue(substyleKey + "font_bold", bold) |
| 264 if "font_italic" in style: | 296 if "font_italic" in style: |
| 265 italic = style["font_italic"] | 297 italic = style["font_italic"] |
| 266 else: | 298 else: |
| 267 italic = font.italic() | 299 italic = font.italic() |
| 268 settings.setValue(baseKey + "font_italic", italic) | 300 settings.setValue(substyleKey + "font_italic", italic) |
| 269 if "font_underline" in style: | 301 if "font_underline" in style: |
| 270 underline = style["font_underline"] | 302 underline = style["font_underline"] |
| 271 else: | 303 else: |
| 272 underline = font.underline() | 304 underline = font.underline() |
| 273 settings.setValue(baseKey + "font_underline", underline) | 305 settings.setValue(substyleKey + "font_underline", underline) |
| 274 | 306 |
| 275 def hasSubStyles(self): | 307 def hasSubStyles(self): |
| 276 """ | 308 """ |
| 277 Public method to indicate the support of sub-styles. | 309 Public method to indicate the support of sub-styles. |
| 278 | 310 |
| 292 | 324 |
| 293 def substylesCount(self, style): | 325 def substylesCount(self, style): |
| 294 """ | 326 """ |
| 295 Public method to get the number of defined sub-styles. | 327 Public method to get the number of defined sub-styles. |
| 296 | 328 |
| 329 @param style base style number | |
| 330 @type int | |
| 297 @return number of defined sub-styles | 331 @return number of defined sub-styles |
| 298 @rtype int | 332 @rtype int |
| 299 """ | 333 """ |
| 300 if style in self.__subStyles: | 334 if style in self.__subStyles: |
| 301 count = len(self.__subStyles[style]) | 335 count = len(self.__subStyles[style]) |
| 672 | 706 |
| 673 return font | 707 return font |
| 674 | 708 |
| 675 def addSubstyle(self, style): | 709 def addSubstyle(self, style): |
| 676 """ | 710 """ |
| 677 Public method to add a sub-style to a given base style. | 711 Public method to add an empty sub-style to a given base style. |
| 678 | 712 |
| 679 @param style base style number | 713 @param style base style number |
| 680 @type int | 714 @type int |
| 681 @return allocated sub-style number | 715 @return allocated sub-style number or -1 to indicate an error |
| 682 @rtype int | 716 @rtype int |
| 683 """ | 717 """ |
| 684 # TODO: implement this | 718 if style in self.__subStyles: |
| 685 # add empty sub-style definition | 719 lastSubStyle = sorted(self.__subStyles[style].keys())[-1] |
| 720 subStyle = lastSubStyle + 1 | |
| 721 self.__subStyles[style][subStyle] = { | |
| 722 "Description": "", | |
| 723 "Words": "", | |
| 724 "Style": {}, | |
| 725 } | |
| 726 else: | |
| 727 subStyle = -1 | |
| 728 | |
| 729 return subStyle | |
| 686 | 730 |
| 687 def delSubstyle(self, style, substyle): | 731 def delSubstyle(self, style, substyle): |
| 688 """ | 732 """ |
| 689 Public method to delet a given sub-style definition. | 733 Public method to delet a given sub-style definition. |
| 690 | 734 |
