pyqt qscintill PyEditor

##

 

# encoding: utf-8
import PyQt5.Qsci as sci
# import PyQt5.QtWidgets as wgt
import os 
from PyQt5.QtWidgets import *
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.Qsci import *
import textwrap 

import jedi
# jedi.settings.case_insensitive_completion=True
# jedi.settings.add_bracket_after_function= True
# jedi.settings.fast_parser= False


src='''import matplotlib.pyplot as plt
import numpy as np
x0=np.linspace( 0 , 30 ,  600 );y0=x0*np.sin(x0 ) 
plt.plot(x0 , y0 );plt.show()
'''
app=QApplication( [] ) 
mn=QMainWindow( )

class scintillaEditor( sci.QsciScintilla):
    def __init__(self , parent=None ):
        super( ) . __init__( parent)
        self.SendScintilla(self.SCI_STYLESETFONT, 1, b'Courier')
#         self.SendScintilla(self.sci_gettext, 1, b'Courier')
        
        self._editorFont=QFont("宋体",16,QFont.Normal)
        self.setMarginLineNumbers(0, True)
        self.setMarginSensitivity(0, True)
        self.setMarginWidth( 0 , 32)
        self.append( src)
        # txt.changeEvent( )
        self.setFont( self._editorFont )
        self.zoomTo( 4 )
        
        
        """
        Setup the call tip options
        """
        # Select the context at which the call tips are displayed.
        # This selects when call tips are active, depending of the 
        # scope like a C++ namespace or Python module.
        self.setCallTipsStyle(QsciScintilla.CallTipsNoContext)
        # Set the number of calltips that will be displayed at one time.
        # 0 shows all applicable call tips.
        self.setCallTipsVisible(0)
        # This selects the position at which the call tip rectangle will appear.
        # If it is not possible to show the call tip rectangle at the selected position
        # because it would be displayed outside the bounds of the document, it will be
        # displayed where it is possible.
        self.setCallTipsPosition(QsciScintilla.CallTipsAboveText)
        # Select the various highlight colors
        # Background
        self.setCallTipsBackgroundColor(QColor(0xff, 0xff, 0xff, 0xff))
        # Text
        self.setCallTipsForegroundColor(QColor(0x50, 0x50, 0x50, 0xff))
        # Current argument text
        self.setCallTipsHighlightColor(QColor(0xff, 0x00, 0x00, 0xff))        
        
        """
        Autocompletion options - Basic
        """
        # Set the autocompletion to be case IN-sensitive
        self.setAutoCompletionCaseSensitivity(False)
        # Set the threshold at which the autocompletion window appears
        self.setAutoCompletionThreshold(1)
        # Set the source from which the autocompletions will be pulled from
        self.setAutoCompletionSource(QsciScintilla.AcsAll)
        # Sets whether the characters to the right of the autocompletion
        # will be overwritten when an autocompletion is selected.
        self.setAutoCompletionReplaceWord(True)
        # Select the behaviour of autocompletions when there is only a single
        # entry in the autocompletion list. The selection below sets that
        # when the autocompletion window will always be displayed.
        self.setAutoCompletionUseSingle(QsciScintilla.AcusNever)
        
        self.lexer_instance=sci.QsciLexerPython( )
        self.setLexer( self.lexer_instance )
        self.api_instance=sci.QsciAPIs(self.lexer_instance)
 
class frameToolBarMnu( QFrame ):
    '''
    action_out=.toolbar.addAction( "caption" , action_out_CallBackFunc)
            @pyqtSlot()        
            def def toolBar_open_Func():
                ...
                
    menu_out=.menu.addAction( "title" , menu_out_CallBackFunc)
            @pyqtSlot()        
            def def toolBar_open_Func():
                ...
    '''
    def __init__ (self , parent=None):
        super( ) .__init__( parent)
        
        fontMn=QFont("黑体",16,QFont.Bold)
        
        self._vbox_=QVBoxLayout( self )
        self.splitter =QSplitter( self )
        self.splitter.setOrientation( 0 )
        self.toolbar=QToolBar(self)
        self.toolbar.setFont( fontMn)
        
        action_open=self.toolbar.addAction( "open" , self.toolBar_open_Func )
        action_save=self.toolbar.addAction( "save" , self.toolBar_save_Func)
        action_new=self.toolbar.addAction( "new" , self.toolBar_new_Func)
        action_execl=self.toolbar.addAction( "execl" , self.toolBar_Exec_Func )
        # action_execl=self.toolbar.addAction( "jedi" , toolBar_Jedi_Func )
        self.jediBtn=QPushButton( 'jedi' ,self)
        self.jediBtn.setCheckable( True)
        self.toolbar.addWidget( self.jediBtn )      

        
        self.menu=QMenuBar(self)
        self.menu.setFont( fontMn)
        
        self._vbox_.addWidget( self.menu )
        self._vbox_.addWidget( self.toolbar )
        self._vbox_.addWidget( self.splitter ) 
        
        self.editorMain=scintillaEditor( self  )
        self.editorMain.textChanged.connect( self.editorMain_onTextChanged )
        self.__filePath__=''
        
        self.statusbarMain=QStatusBar( self )
        self.label_ssbar01=QLabel( 'label01', self)
        self.statusbarMain.addWidget( self.label_ssbar01 )
        self._vbox_.addWidget(   self.statusbarMain )
        
        
    def test(self):
        self.menu.addMenu("file")
        self.menu.addMenu("view")
        self.menu.addMenu("edit")
        
    @pyqtSlot()
    def toolBar_Exec_Func( self ):
        try:
            exec( self.editorMain.text() )
        except Exception as e:
            print(e)
    @pyqtSlot()        
    def toolBar_open_Func(self):
        filename=QFileDialog.getOpenFileName( fm ,'open file','/home/jm/study')
        print( filename )
        if os.path.exists(  filename[0] )==False:
            return
        if filename[0] in [ "" , " " , None] :
            return
        self.__filePath__=filename[0]
        
        with open(filename[0],'r') as f:
            my_txt=f.read()
            self.editorMain.setText(my_txt)
    @pyqtSlot()        
    def toolBar_save_Func( self ):
        if self.__filePath__=="" or self.__filePath__ is None :
            filename=QFileDialog.getSaveFileName(fm,'save file','/home/jm/study')
        else:
            filename=[self.__filePath__]
        with open(filename[0],'w') as f:
            my_text=editor.text( )
            f.write(my_text)
            
    @pyqtSlot()
    def toolBar_new_Func(self):
        self.editorMain.setText( "#encoding: utf-8\n")
        self.__filePath__= "" 
            
#     @pyqtSlot()        
#     def toolBar_Jedi_Func():
#         return    

            
    def editorMain_onTextChanged (self ):        
        pos=self.editorMain.SendScintilla( self.editorMain.SCI_GETCURRENTPOS, 0 , 0)        
        sp=self.editorMain.SendScintilla( self.editorMain.SCI_WORDSTARTPOSITION , pos , True )
        ep=self.editorMain.SendScintilla( self.editorMain.SCI_WORDENDPOSITION, pos , True  )
        
        print( self.editorMain.text( ) [ sp:ep] )
        
#         self.editorMain.SendScintilla( self.editorMain.SCI_SETSEL , sp , ep)              
        
         
        
        api=self.editorMain.api_instance
        mtxt= self.editorMain.text( )
        api.clear( )
        if self.jediBtn.isChecked( )==False:
            for i in buildFuncs :
                api.add( i)
            api.prepare()
            return
        pos=editor.getCursorPosition( )
        x,y=pos
        if(len(mtxt)==0 ):return     
        JdSrc=jedi.Script( mtxt , path='tmp.py')         
        try:    
            completes=JdSrc.complete( x+1 , y) # 注意 line坐标从1开始 
        except Exception as e:
            print( e)  
        else:     
            for i in completes:  
                api.add( i.name)     
#                 docstr=textwrap.shorten( i.docstring() ,  width=256, placeholder="...")
#                 api.add(  i.docstring()  )
            api.prepare( ) 
        return
      
fm=frameToolBarMnu(mn )
editor02=QsciScintilla( mn )
editor=fm.editorMain # fm.test()

fm.splitter.addWidget( editor)
fm.splitter.addWidget( editor02)
mn.setCentralWidget( fm )
toolbar01=fm.toolbar     

# lx=sci.QsciLexerPython( )
# editor.setLexer( lx )
# api=sci.QsciAPIs(lx)

# api.add("for while import return ") 
 
funcs = [
    "test_autocompletion",
    "add(int arg_1, float arg_2) Add two integers together", # This call tip has a description
    "subtract(int arg_1, test arg_2)",
    "subtract(float arg_1, float arg_2)", 
    "subtract(test arg_1, test arg_2)", 
    "divide(float div_1, float div_2)",
    "some_func(arg_3)"
]
# Add the functions to the api
for s in funcs:
    fm.editorMain.api_instance.add(s)
    
     
# Create a list of autocompletions
test_autocompletions = [
    "test_autocompletion",
    "autocompletion_with_image?1",
    "another_autocompletion?2",
    "subtract?1(int arg_1, float arg_2) Subtract function", # This call tip has a description and an image
    "entry_that_will_be_removed_later"
]

buildFuncs=['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError', 
'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 
'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 
'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 
'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError',
 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 
 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 
 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 
 'ProcessLookupError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 
 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 
 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError',
 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 
 'WindowsError', 'ZeroDivisionError', '__IPYTHON__', '__build_class__', '__debug__', '__doc__',
 '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'all', 'any', 'ascii', 'bin',
 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'cell_count', 'chr', 'classmethod', 'compile', 'complex', 
 'copyright', 'credits', 'debugcell', 'debugfile', 'delattr', 'dict', 'dir', 'display', 'divmod', 'enumerate', 'eval', 
 'exec', 'execfile', 'filter', 'float', 'format', 'frozenset', 'get_ipython', 'getattr', 'globals', 'hasattr', 'hash', 'help', 
 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 
 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'range', 'repr', 'reversed', 'round', 'runcell',
 'runfile', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']


import keyword
buildFuncs=buildFuncs+keyword.kwlist

# Add the functions to the api
for ac in test_autocompletions:
    fm.editorMain.api_instance.add(ac)
# Example of removing an entry
fm.editorMain.api_instance.remove("entry_that_will_be_removed_later")
# Prepare the QsciAPIs instance information
fm.editorMain.api_instance.prepare()
 

if __name__ == '__main__':
    scn=fm.editorMain
    xx=b' '
    fm.editorMain.SendScintilla( scn.SCI_GETLINE, 1 , xx)
    print( xx )
    mn.show( )
    app.exec( )
    

 

 

##