eric: comparison UI/Previewer.py

-:9986ec0e559a
+:10516539f238
 self.__vm = viewmanager
 self.__splitter = splitter
 self.__firstShow = True
-self.previewView.page().setLinkDelegationPolicy(QWebPage.DelegateAllLinks)
+self.previewView.page().setLinkDelegationPolicy(
+QWebPage.DelegateAllLinks)
 # Don't update too often because the UI might become sluggish
 self.__typingTimer = QTimer()
 self.__typingTimer.setInterval(500)     # 500ms
 self.__typingTimer.timeout.connect(self.__runProcessingThread)
 """
 Public method to show the preview widget.
 """
 super(Previewer, self).show()
 if self.__firstShow:
-self.__splitter.restoreState(Preferences.getUI("PreviewSplitterState"))
+self.__splitter.restoreState(
-self.jsCheckBox.setChecked(Preferences.getUI("ShowFilePreviewJS"))
+Preferences.getUI("PreviewSplitterState"))
-self.ssiCheckBox.setChecked(Preferences.getUI("ShowFilePreviewSSI"))
+self.jsCheckBox.setChecked(
+Preferences.getUI("ShowFilePreviewJS"))
+self.ssiCheckBox.setChecked(
+Preferences.getUI("ShowFilePreviewSSI"))
 self.__firstShow = False
 self.__typingTimer.start()
 def hide(self):
 """
 """
 if editor is None:
 self.hide()
 return
-if Preferences.getUI("ShowFilePreview") and self.__isPreviewable(editor):
+if Preferences.getUI("ShowFilePreview") and \
+self.__isPreviewable(editor):
 self.show()
 self.__runProcessingThread()
 else:
 self.hide()
 else:
 self.hide()
 def __isPreviewable(self, editor):
 """
-Private method to check, if a preview can be shown for the given editor.
+Private method to check, if a preview can be shown for the given
+editor.
 @param editor reference to an editor (Editor)
 @return flag indicating if a preview can be shown (boolean)
 """
 if editor:
 if editor.getFileName() is not None:
 extension = os.path.normcase(
 os.path.splitext(editor.getFileName())[1][1:])
 return extension in \
 Preferences.getEditor("PreviewHtmlFileNameExtensions") + \
-Preferences.getEditor("PreviewMarkdownFileNameExtensions") + \
+Preferences.getEditor(
+"PreviewMarkdownFileNameExtensions") + \
 Preferences.getEditor("PreviewRestFileNameExtensions")
 elif editor.getLanguage() == "HTML":
 return True
 return False
 language = "Markdown"
 elif extension in \
 Preferences.getEditor("PreviewRestFileNameExtensions"):
 language = "ReST"
 else:
-self.__setHtml(fn,
+self.__setHtml(fn, self.trUtf8(
-self.trUtf8("<p>No preview available for this type of file.</p>"))
+"<p>No preview available for this type of file.</p>"))
 return
 if fn:
 project = e5App().getObject("Project")
 if project.isProjectFile(fn):
 fn, language, editor.text(),
 self.ssiCheckBox.isChecked(), rootPath)
 def __setHtml(self, filePath, html):
 """
-Private method to set the HTML to the view and restore the scroll bars positions.
+Private method to set the HTML to the view and restore the scroll bars
+positions.
 @param filePath file path of the previewed editor (string)
 @param html processed HTML text ready to be shown (string)
 """
 self.__saveScrollBarPositions()
 if self.__previewedPath not in self.__scrollBarPositions:
 return
 frame = self.previewView.page().mainFrame()
-frame.setScrollPosition(self.__scrollBarPositions[self.__previewedPath])
+frame.setScrollPosition(
+self.__scrollBarPositions[self.__previewedPath])
 if self.__hScrollBarAtEnd[self.__previewedPath]:
-frame.setScrollBarValue(Qt.Horizontal, frame.scrollBarMaximum(Qt.Horizontal))
+frame.setScrollBarValue(
+Qt.Horizontal, frame.scrollBarMaximum(Qt.Horizontal))
 if self.__vScrollBarAtEnd[self.__previewedPath]:
-frame.setScrollBarValue(Qt.Vertical, frame.scrollBarMaximum(Qt.Vertical))
+frame.setScrollBarValue(
+Qt.Vertical, frame.scrollBarMaximum(Qt.Vertical))
 @pyqtSlot(QUrl)
 def on_previewView_linkClicked(self, url):
 """
 Private slot handling the clicking of a link.
 class PreviewProcessingThread(QThread):
 """
 Class implementing a thread to process some text into HTML usable by the
 previewer view.
-@signal htmlReady(str,str) emitted with the file name and processed HTML to signal
+@signal htmlReady(str,str) emitted with the file name and processed HTML
-the availability of the processed HTML
+to signal the availability of the processed HTML
 """
 htmlReady = pyqtSignal(str, str)
 def __init__(self, parent=None):
 """
 Convert the given text to HTML.
 @param filePath file path of the text (string)
 @param language language of the text (string)
 @param text text to be processed (string)
-@param ssiEnabled flag indicating to do some (limited) SSI processing (boolean)
+@param ssiEnabled flag indicating to do some (limited) SSI processing
+(boolean)
 @param rootPath root path to be used for SSI processing (str)
 """
 with self.__lock:
 self.__filePath = filePath
 self.__language = language
 text = self.__text
 ssiEnabled = self.__ssiEnabled
 rootPath = self.__rootPath
 self.__haveData = False
-html = self.__getHtml(language, text, ssiEnabled, filePath, rootPath)
+html = self.__getHtml(language, text, ssiEnabled, filePath,
+rootPath)
 with self.__lock:
 if not self.__haveData:
 self.htmlReady.emit(filePath, html)
 break
 # else - next iteration
 def __getHtml(self, language, text, ssiEnabled, filePath, rootPath):
 """
-Private method to process the given text depending upon the given language.
+Private method to process the given text depending upon the given
+language.
 @param language language of the text (string)
 @param text to be processed (string)
-@param ssiEnabled flag indicating to do some (limited) SSI processing (boolean)
+@param ssiEnabled flag indicating to do some (limited) SSI processing
+(boolean)
 @param filePath file path of the text (string)
 @param rootPath root path to be used for SSI processing (str)
+@return processed HTML text (string)
 """
 if language == "HTML":
 if ssiEnabled:
 return self.__processSSI(text, filePath, rootPath)
 else:
 elif language == "Markdown":
 return self.__convertMarkdown(text)
 elif language == "ReST":
 return self.__convertReST(text)
 else:
-return self.trUtf8("<p>No preview available for this type of file.</p>")
+return self.trUtf8(
+"<p>No preview available for this type of file.</p>")
 def __processSSI(self, txt, filename, root):
 """
 Private method to process the given text for SSI statements.
 Note: Only a limited subset of SSI statements are supported.
 @param txt text to be processed (string)
-@param filename name of the file associated with the given text (string)
+@param filename name of the file associated with the given text
+(string)
 @param root directory of the document root (string)
 @return processed HTML (string)
 """
 if not filename:
 return txt
 """
 try:
 import docutils.core    # __IGNORE_EXCEPTION__ __IGNORE_WARNING__
 except ImportError:
 return self.trUtf8(
-"""<p>ReStructuredText preview requires the <b>python-docutils</b> """
+"""<p>ReStructuredText preview requires the"""
-"""package.<br/>Install it with your package manager or see """
+""" <b>python-docutils</b> package.<br/>Install it with"""
-"""<a href="http://pypi.python.org/pypi/docutils">this page.</a></p>""")
+""" your package manager or see"""
+""" <a href="http://pypi.python.org/pypi/docutils">"""
-return docutils.core.publish_string(text, writer_name='html').decode("utf-8")
+"""this page.</a></p>""")
+return docutils.core.publish_string(text, writer_name='html')\
+.decode("utf-8")
 def __convertMarkdown(self, text):
 """
 Private method to convert Markdown text into HTML.
 extensions = ['fenced_code', 'nl2br', 'extra']
 # version 2.0 supports only extension names, not instances
 if markdown.version_info[0] > 2 or \
-(markdown.version_info[0] == 2 and markdown.version_info[1] > 0):
+(markdown.version_info[0] == 2 and
+markdown.version_info[1] > 0):
 class _StrikeThroughExtension(markdown.Extension):
 """
 Class is placed here, because it depends on imported markdown,
 and markdown import is lazy.
-(see
+(see http://achinghead.com/
-<a href="http://achinghead.com/python-markdown-adding-insert-delete.html">
+python-markdown-adding-insert-delete.html this page for
-this page for details</a>)
+details)
 """
 DEL_RE = r'(~~)(.*?)~~'
 def extendMarkdown(self, md, md_globals):
 # Create the del pattern
-del_tag = markdown.inlinepatterns.SimpleTagPattern(self.DEL_RE, 'del')
+del_tag = markdown.inlinepatterns.SimpleTagPattern(
+self.DEL_RE, 'del')
 # Insert del pattern into markdown parser
 md.inlinePatterns.add('del', del_tag, '>not_strong')
 extensions.append(_StrikeThroughExtension())
 try:
 return markdown.markdown(text,  extensions + ['mathjax'])
 except (ImportError, ValueError):
 # markdown raises ValueError or ImportError, depends on version
-# It is not clear, how to distinguish missing mathjax from other errors.
+# It is not clear, how to distinguish missing mathjax from other
-# So keep going without mathjax.
+# errors. So keep going without mathjax.
 return markdown.markdown(text, extensions)

Mercurial Repositories > eric / file comparison

comparison: UI/Previewer.py

UI/Previewer.py