def buildWorkFrame(self): """Creates the grouped set of widgets that allow users to build basic Clause objects. """ groupBox = QGroupBox("Clause Workspace") layout = QHBoxLayout(groupBox) attributeCompleter = QCompleter(self.attributes) attributeCompleter.setCompletionMode(QCompleter.InlineCompletion) self.dropAttribute = DropLineEdit(self, self.mframe.agent.datatree, "", attributeCompleter) self.dropRelation = DropTextLabel("__") self.dropValue = FilterValueLineEdit(groupBox, self.mframe.agent.datatree, self.dropAttribute) # Clear dropValue when dropAttribute changes self.dropAttribute.textChanged.connect(self.dropValue.clear) # Enter in dropValue works like addButton self.dropValue.returnPressed.connect(self.addClause) self.addButton = QPushButton("Add", groupBox) self.addButton.clicked.connect(self.addClause) layout.addWidget(self.dropAttribute) layout.addItem(QSpacerItem(5,5)) layout.addWidget(self.dropRelation) layout.addItem(QSpacerItem(5,5)) layout.addWidget(self.dropValue) layout.addItem(QSpacerItem(5,5)) layout.addWidget(self.addButton) groupBox.setLayout(layout) return groupBox
def config_completer(line_edit, model, field): # sets up a completer based on a QSqlTableModel for the specified field on a QLineEdit completer = QCompleter() completer.setModel(model) completer.setCompletionColumn(model.fieldIndex(field)) completer.setCompletionMode(QCompleter.PopupCompletion) completer.setCaseSensitivity(Qt.CaseInsensitive) completer.activated.connect(line_edit.returnPressed) line_edit.setCompleter(completer)
def focusInEvent(self, e): """On focus, this completer for this LineEdit will update its values based on the attribute named in the watchLineEdit. """ super(FilterValueLineEdit, self).focusInEvent(e) if self.oldText != self.watchLineEdit.text(): self.oldText = self.watchLineEdit.text() values = self.datatree.getAttributeValues( self.watchLineEdit.text()) self.setCompleter(None) new_completer = QCompleter(values) new_completer.setCompletionMode(QCompleter.InlineCompletion) self.setCompleter(new_completer)
def createEditor(self,parent,option,index): # Qt takes ownership of the editor # Therefore I have recreate it each time this method is called combo = QComboBox(parent) combo.setModel(self.model) completer = QCompleter(combo) completer.setModel(self.model) completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion) # PopupCompletion) combo.setCompleter(completer) if option: # This is needed to put the combobox in the right place combo.setGeometry(option.rect) return combo
class ComboBoxWithTypingSearch(QComboBox): def __init__(self, parent=None): super(ComboBoxWithTypingSearch, self).__init__(parent) self.setFocusPolicy(Qt.StrongFocus) self.setEditable(True) self.completer = QCompleter(self) # always show all completions self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion) self.pFilterModel = QSortFilterProxyModel(self) self.pFilterModel.setFilterCaseSensitivity(Qt.CaseInsensitive) self.completer.setPopup(self.view()) self.setCompleter(self.completer) self.lineEdit().textEdited.connect( self.pFilterModel.setFilterFixedString) self.completer.activated.connect(self.setTextIfCompleterIsClicked) def setModel(self, model): super(ComboBoxWithTypingSearch, self).setModel(model) self.pFilterModel.setSourceModel(model) self.completer.setModel(self.pFilterModel) def setModelColumn(self, column): self.completer.setCompletionColumn(column) self.pFilterModel.setFilterKeyColumn(column) super(ComboBoxWithTypingSearch, self).setModelColumn(column) def view(self): return self.completer.popup() def index(self): return self.currentIndex() def setTextIfCompleterIsClicked(self, text): if text: index = self.findText(text) self.setCurrentIndex(index)
class CodeCompletionMode(Mode): """ This mode provides code completion to the CodeEdit widget. The list of suggestion is supplied by a CodeCompletionModel. Code completion may use more than one completion model. The suggestions list is then filled model per model by beginning by the highest priority as long as the number of suggestions is lower than :attr:`pcef.modes.code_completion.CodeCompletion.minSuggestions`. For example, a python editor will use a smart completion model with a high priority and use the DocumentWordsCompletion model as a fallback system when the smart model fails to provide enough suggestions. The mode uses a QCompleter to provides display the list of suggestions. Code completion is triggered using ctrl+space or when there is at least three characters in the word being typed. """ #: Mode identifier IDENTIFIER = "Code completion" #: Mode description DESCRIPTION = "Provides code completion though completion models" def __init__(self): super(CodeCompletionMode, self).__init__( self.IDENTIFIER, self.DESCRIPTION) self.thread_pool = QThreadPool() self.thread_pool.setMaxThreadCount(2) self.__cached_request = None self.__active_thread_count = 0 self.__updating_models = False self.__timer = QTimer() #: Defines the min number of suggestions. This is used to know we should # avoid using lower priority models. # If there is at least minSuggestions in the suggestions list, we won't # use other completion model. self.minSuggestions = 50 #: Trigger key (automatically associated with the control modifier) self.triggerKey = Qt.Key_Space #: Number of chars needed to trigger the code completion self.nbTriggerChars = 1 #: Tells if the completion should be triggered automatically (when # len(wordUnderCursor) > nbTriggerChars ) # Default is True. Turning this option off might enhance performances # and usability self.autoTrigger = True self.periodIsTrigger = True #: Show/Hide current suggestion tooltip self.displayTooltips = True self.__caseSensitivity = Qt.CaseSensitive #: The internal QCompleter self.__completer = QCompleter() # self.__completer.activated.connect(self._insertCompletion) self.__completer.highlighted.connect(self._onHighlighted) self.__completer.activated.connect(self._insertCompletion) self.__prev_txt_len = 0 #: List of completion models self._models = [] self.__tooltips = {} def __del__(self): self.__completer.setWidget(None) self.__completer = None def addModel(self, model): """ Adds a completion model to the completion models list. :param model: CompletionModel to add """ self._models.append(model) self._models = sorted(self._models, key=lambda mdl: mdl.priority, reverse=True) def install(self, editor): """ Setup the completer with the CodeEdit. :param editor: CodeEditorWidget instance """ super(CodeCompletionMode, self).install(editor) self.__completer.setWidget(editor.codeEdit) self.__completer.setCaseSensitivity(self.__caseSensitivity) self.__completer.setCompletionMode(QCompleter.PopupCompletion) def __set_case(self, case): if case != self.__caseSensitivity: self.__caseSensitivity = case self.__completer.setCaseSensitivity(case) def __get_case(self): return self.__caseSensitivity #: The completion case sensitivity caseSensitivity = property(__get_case, __set_case) def _onStateChanged(self, state): """ Enables/Disables code completion. :param state: True to enable, False to disable """ if state: self.editor.codeEdit.keyPressed.connect(self._onKeyPressed) self.editor.codeEdit.postKeyPressed.connect(self._onKeyReleased) self.editor.codeEdit.focusedIn.connect(self._onFocusIn) self.__completer.highlighted.connect( self._displayHighlightedTooltip) else: self.editor.codeEdit.keyPressed.disconnect(self._onKeyPressed) self.editor.codeEdit.postKeyPressed.disconnect(self._onKeyReleased) self.editor.codeEdit.focusedIn.disconnect(self._onFocusIn) self.__completer.highlighted.disconnect( self._displayHighlightedTooltip) def _onFocusIn(self, event): """ Resets completer widget :param event: QFocusEvent """ self.__completer.setWidget(self.editor.codeEdit) def _onHighlighted(self, completion): """ Remembers the current completion when the hilighted signal is emitted. :param completion: Current completion """ self.currentCompletion = completion def _onKeyReleased(self, event): """ Handles the key released event to adapt completer prefix, run the cc library if necessary or prevent completer popup when removing text. :param event: :return: """ word = self._textUnderCursor() isShortcut = self._isShortcut(event) or event.key() == Qt.Key_Period tooShort = len(word) < self.nbTriggerChars # closes popup if completion prefix is empty and we are not removing # some text if (not self.__completer.popup().isVisible() and event.key() == Qt.Key_Backspace or event.key() == Qt.Key_Delete) or\ (not isShortcut and event.modifiers() == 0 and ( word.isspace() or word == "")): self._hideCompletions() return # . is an auto-trigger if self.periodIsTrigger and \ (event.key() == Qt.Key_Period and self.autoTrigger): self._requestCompletion(completionPrefix=word, onlyAdapt=False) return # adapt completion prefix if self.__completer.popup().isVisible(): self._requestCompletion(completionPrefix=word, onlyAdapt=True) # run cc if word is long enough and auto trigger is on elif not tooShort and self.autoTrigger and event.text() != "" \ and (event.modifiers() == 0 or event.modifiers() & Qt.ShiftModifier): self._requestCompletion(completionPrefix=word, onlyAdapt=False) def _isShortcut(self, event): """ Checks if the event's key and modifiers make the completion shortcut. :param event: QKeyEvent :return: bool """ return ((event.modifiers() & Qt.ControlModifier > 0) and event.key() == self.triggerKey) def _onKeyPressed(self, event): """ Trigger the completion with ctrl+triggerKey and handle completion events ourselves (insert completion and hide completer) :param event: QKeyEvent """ isShortcut = self._isShortcut(event) completionPrefix = self._textUnderCursor() # handle completer popup events ourselves if self.__completer.popup().isVisible(): # complete if event.key() == Qt.Key_Enter or event.key() == Qt.Key_Return: self._insertCompletion(self.currentCompletion) self.__completer.popup().hide() event.stop = True return # hide elif event.key() == Qt.Key_Escape or event.key() == Qt.Key_Backtab: self.__completer.popup().hide() event.stop = True return # user completion request: update models and show completions if isShortcut: self._requestCompletion(completionPrefix, onlyAdapt=False) if event.key() == self.triggerKey: event.stop = True def selectWordUnderCursor(self): tc = self.editor.codeEdit.textCursor() original_pos = pos = tc.position() space_found = False how_many = 0 while not space_found and pos != 0: tc.movePosition(QTextCursor.Left, QTextCursor.MoveAnchor, 1) tc.movePosition(QTextCursor.Left, QTextCursor.KeepAnchor, 1) ch = tc.selectedText()[0] if tc.selectedText() in WORD_SEPARATORS or ch.isspace(): space_found = True how_many += 1 pos = tc.position() tc.movePosition(QTextCursor.Right, QTextCursor.MoveAnchor, 1) tc.setPosition(original_pos) tc.movePosition(QTextCursor.Left, QTextCursor.KeepAnchor, how_many) return tc def _textUnderCursor(self): """ Returns the word under the cursor """ tc = self.selectWordUnderCursor() selectedText = tc.selectedText() tokens = selectedText.split('.') wuc = tokens[len(tokens) - 1] if selectedText == ".": wuc = '.' return wuc def _lastCharOfLine(self): """ Returns the last char of the active line. :return: unicode """ tc = self.editor.codeEdit.textCursor() tc.movePosition(QTextCursor.Left, QTextCursor.KeepAnchor, 1) return tc.selectedText() def _getCCRequest(self, completionPrefix): """ Creates a CompletionRequest from context (line nbr, ...) :param completionPrefix: the completion request prefix """ tc = self.editor.codeEdit.textCursor() line = tc.blockNumber() + 1 col = tc.columnNumber() fn = self.editor.codeEdit.tagFilename encoding = self.editor.codeEdit.tagEncoding source = self.editor.codeEdit.toPlainText() return CompletionRequest( col=col, encoding=encoding, filename=fn, line=line, source_code=source, completionPrefix=completionPrefix) def _execRequest(self, request): """ Executes a cc request and emit __completionResultsAvailable when the execution is done. :param request: The CodeCompletionRequest to execute. """ pass def _createCompleterModel(self, completionPrefix): """ Creates a QStandardModel that holds the suggestion from the completion models for the QCompleter :param completionPrefix: """ # build the completion model cc_model = QStandardItemModel() cptSuggestion = 0 displayedTexts = [] self.__tooltips.clear() for model in self._models: for s in model.suggestions: # skip redundant completion if s.display != completionPrefix and \ not s.display in displayedTexts: displayedTexts.append(s.display) items = [] item = QStandardItem() items.append(item) item.setData(s.display, Qt.DisplayRole) if s.description is not None: self.__tooltips[s.display] = s.description if s.decoration is not None: item.setData(QIcon(s.decoration), Qt.DecorationRole) cc_model.appendRow(items) cptSuggestion += 1 # do we need to use more completion model? if cptSuggestion >= self.minSuggestions: break # enough suggestions return cc_model, cptSuggestion def _showCompletions(self, completionPrefix): """ Shows the completion popup :param completionPrefix: completion prefix use to set the popup pos """ c = self.__completer c.setCompletionPrefix(completionPrefix) c.popup().setCurrentIndex( self.__completer.completionModel().index(0, 0)) cr = self.editor.codeEdit.cursorRect() charWidth = self.editor.codeEdit.fm.width('A') cr.setX(cr.x() - len(completionPrefix) * charWidth) cr.setWidth(400) c.complete(cr) # popup it up! self._displayHighlightedTooltip(c.currentCompletion()) def _hideCompletions(self): """ Hides the completion popup """ self.__completer.popup().hide() QToolTip.hideText() def _requestCompletion(self, completionPrefix, onlyAdapt=False): """ Requests a code completion. The request will be transmitted to the background thread and treated by the __applyRequestResults slot when __completionResultsAvailable is emitted. :param completionPrefix: :param onlyAdapt: :return: """ # cancel prev running request if not onlyAdapt: request = self._getCCRequest(completionPrefix) else: request = CompletionRequest(completionPrefix=completionPrefix, onlyAdapt=True) # only one at a time if self.__active_thread_count == 0: if self.__cached_request: self.__cached_request, request = request, self.__cached_request self.__active_thread_count += 1 runnable = RunnableCompleter(self._models, request) runnable.connect(self._applyRequestResults) self.thread_pool.start(runnable) # cache last request else: self.__cached_request = request def _applyRequestResults(self, request): """ Updates the completer model and show the popup """ self.__active_thread_count -= 1 # is the request still up to date ? if request.completionPrefix == self._textUnderCursor(): if not request.onlyAdapt: # update completion model and show completer cc_model, cptSuggestion = self._createCompleterModel( request.completionPrefix) if cptSuggestion > 1: self.__completer.setModel(cc_model) self.__cc_model = cc_model self._showCompletions(request.completionPrefix) else: self._hideCompletions() else: # only adapt completion prefix, the completer is already visible self.__completer.setCompletionPrefix(request.completionPrefix) idx = self.__completer.completionModel().index(0, 0) self.__completer.popup().setCurrentIndex(idx) if self.__completer.currentCompletion() == "" or \ self.__completer.currentCompletion() == \ request.completionPrefix: self._hideCompletions() # do we have any cached requests? if self.__cached_request and self.__active_thread_count == 0: self.__active_thread_count += 1 # prevent normal start immediately self.__timer.singleShot(10, self.__start_cached_request) def __start_cached_request(self): request = self.__cached_request self.__cached_request = None runnable = RunnableCompleter(self._models, request) runnable.connect(self._applyRequestResults) self.thread_pool.start(runnable) @Slot(unicode) def _displayHighlightedTooltip(self, txt): """ Shows/hides current suggestion tooltip next to the completer popup :param txt: :return: """ if not self.displayTooltips or not txt in self.__tooltips: QToolTip.hideText() return tooltip = self.__tooltips[txt] charWidth = self.editor.codeEdit.fm.width('A') # show tooltip pos = self.__completer.popup().pos() pos.setX(pos.x() + 400) pos.setY(pos.y() - 15) QToolTip.showText(pos, tooltip, self.editor.codeEdit) def _insertCompletion(self, completion): """ Inserts the completion (replace the word under cursor) :param completion: the completion text to insert """ offset = 0 if len(self._textUnderCursor()) > 1: offset = 1 tc = self.selectWordUnderCursor() tc.insertText(completion) self.editor.codeEdit.setTextCursor(tc)
def __init__(self, model, index, parent=None): super(ObservationDialog, self).__init__(parent) self.logger = Logger('root.observationDialog') self.logger.debug('Debug set to: %s' % str(parent.logger.debugging)) self.setupUi(self) # self.dateTimeEdit.setDateTime(QDateTime.currentDateTime()) # An observation model is passed to the constructor as a parameter self.model = model # Build a QCompleter that is based on a species model's species name. # This way user can start typing the name in a line edit and the # completion will suggest suitable species names based on the model # TODO: language for the species name completion needs to be handled # TODO: both completers have model column indexes hard coded in, thus # they will break if the model is modified sppCompleter = QCompleter(self) sppCompleter.setModel(self.model.data_model) sppCompleter.setCompletionColumn(4) sppCompleter.setCompletionMode(QCompleter.InlineCompletion) sppCompleter.setCaseSensitivity(Qt.CaseInsensitive) self.sppLineEdit.setCompleter(sppCompleter) # Build a QCompleter that is based on a species model's abbreviation. # This way user can start typing the abbreviation in a line edit and the # completion will suggest suitable species names based on the model abbrCompleter = QCompleter(self) abbrCompleter.setModel(self.model.data_model) abbrCompleter.setCompletionColumn(1) abbrCompleter.setCompletionMode(QCompleter.InlineCompletion) self.abbrLineEdit.setCompleter(abbrCompleter) # The underlying (observation) model is automatically updated through # a QDataWidgetMapper self.mapper = QDataWidgetMapper(self) self.mapper.setSubmitPolicy(QDataWidgetMapper.ManualSubmit) self.mapper.setModel(model) # ID is mapped to a disabled dummy label in order to include it in the # WidgetMapper --> not very elegant self.mapper.addMapping(self.idLineEdit, model.ID) self.mapper.addMapping(self.sppLineEdit, model.SPECIES) self.mapper.addMapping(self.abbrLineEdit, model.ABBR) self.mapper.addMapping(self.countSpinBox, model.COUNT) self.mapper.addMapping(self.dateTimeEdit, model.TIME) self.mapper.addMapping(self.locLineEdit, model.LOCATION) self.mapper.addMapping(self.notesTextEdit, model.NOTES) self.mapper.setCurrentModelIndex(index) self.firstButton.clicked.connect( lambda: self.saveRecord(ObservationDialog.FIRST)) self.prevButton.clicked.connect( lambda: self.saveRecord(ObservationDialog.PREV)) self.nextButton.clicked.connect( lambda: self.saveRecord(ObservationDialog.NEXT)) self.lastButton.clicked.connect( lambda: self.saveRecord(ObservationDialog.LAST)) self.saveButton.clicked.connect( lambda: self.saveRecord(ObservationDialog.CURRENT)) self.closeButton.clicked.connect(self.reject) self.sppLineEdit.editingFinished.connect(self.update_fields)
class mainwin(QMainWindow): def __init__(self, parent=None): super(mainwin, self).__init__(parent) self.setWindowTitle("Nigandu English to Tamil Dictionary") self.setGeometry(200, 50, 650, 600) self.setMinimumHeight(620) self.setMinimumWidth(650) self.setMaximumHeight(660) self.setMaximumWidth(800) #Setting up status bar self.myStatusBar = QStatusBar() self.myStatusBar.showMessage('Ready', 7000) self.setStatusBar(self.myStatusBar) #Setting up application icon appIcon = QIcon(":/icons/njnlogo.png") self.setWindowIcon(appIcon) # defining the central widget self.central = QWidget(self) #combobox plus search button self.whole = QVBoxLayout(self.central) self.gridlayout = QGridLayout() self.comboBox = QLineEdit(self) #self.comboBox.setEditable(True) self.comboBox.setObjectName("comboBox") self.completer = QCompleter(self.comboBox) self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion) self.completer.setCaseSensitivity(Qt.CaseInsensitive) self.completer.setMaxVisibleItems(10) self.comboBox.setCompleter(self.completer) #self.comboBox.setCompleter() self.gridlayout.addWidget(self.comboBox, 1, 1, 1, 2) self.searchbtn = QPushButton() self.searchbtn.setObjectName("searchbtn") self.searchbtn.setText("&Search") self.gridlayout.addWidget(self.searchbtn, 1, 3) vbox = QVBoxLayout() self.tamtext = QTextBrowser() self.listview = QListWidget(self) #self.listview.setEditTriggers(QAbstractItemView.NoEditTriggers) self.listview.setWindowTitle("Suggested words") self.tamtext.setMinimumHeight(100) self.tamtext.setMaximumHeight(150) vbox.addWidget(self.tamtext) self.suglbl = QLabel(self) self.suglbl.setText("Suggested Words:") vbox.addWidget(self.suglbl) vbox.addWidget(self.listview) self.whole.addLayout(self.gridlayout) self.whole.addLayout(vbox) self.setCentralWidget(self.central) #setting docks self.histdockwidg = QDockWidget("History", self) self.bkmdockwidg = QDockWidget("Book Marks", self) self.histdockwidg.setObjectName("self.histdockwidg") self.bkmdockwidg.setObjectName("self.bkmdockwidg") #self.histdockwidg.setMaximumWidth(histwidth) self.histdockwidg.setAllowedAreas(Qt.RightDockWidgetArea) self.bkmdockwidg.setAllowedAreas(Qt.RightDockWidgetArea) self.histdockwidg.setMaximumWidth(250) self.bkmdockwidg.setMaximumWidth(250) self.histdockwidg.setMinimumWidth(200) self.bkmdockwidg.setMinimumWidth(200) #self.bkmdockwidg.setMaximumWidth(histwidth) self.histli = QListWidget() self.bkmli = QListWidget() self.histlis = [0] self.bkmlistfromfile = [] self.histdockwidg.setWidget(self.histli) self.bkmdockwidg.setWidget(self.bkmli) self.addDockWidget(Qt.RightDockWidgetArea, self.histdockwidg) self.addDockWidget(Qt.RightDockWidgetArea, self.bkmdockwidg) #file menu fi_addwrd = self.createactions("&Add a word...", self.addwrdf, "Alt+A", ":/icons/add.png", "Add a word to the dictionary. . .") fi_options = self.createactions("&Options", self.optionsf, "None", ":/icons/options.png", "Change the default settings. . .") fi_help = self.createactions("&Help", self.helpf, QKeySequence.HelpContents, ":/icons/help.png", "Help contents. . .") fi_quit = self.createactions("&Quit", self.close, QKeySequence.Close, ":/icons/quit.png", "Close the application. . .") fplus = self.createactions("FontPlus", self.fplusf, "None", ":/icons/fplus.png", "Increase the font size") fminus = self.createactions("FontMinus", self.fminusf, "None", ":/icons/fminus.png", "Decrease the font size") #list of file actions fi_menu = (fi_addwrd, fi_options, fi_help, None, fi_quit) #go menu self.go_prev = self.createactions("&Previous Word", self.prevf, "Alt+Z", ":/icons/prev.png", "Previous Word") self.go_next = self.createactions("&Next Word", self.nextf, "Alt+X", ":/icons/next.png", "Next Word") self.go_rand = self.createactions("&Random Word", self.randf, "Ctrl+R", ":/icons/rand.png", "Select a random word") #list of go actions go_menu = (self.go_prev, self.go_next, self.go_rand ) self.go_next.setEnabled(False) self.go_prev.setEnabled(False) #book mark menu self.bkm_addfav = self.createactions("&Bookmark", self.addfavf, "Ctrl+B", ":/icons/bookmark.png", "Book mark this word") self.bkm_viewbkm = self.createactions("&View Bookmarks", self.viewbkmf, "Alt+V", ":/icons/viewbkm.png", "View bookmarked words") #list of book mark items bkm_menu = (self.bkm_addfav, self.bkm_viewbkm) #help menu hlp_about = self.createactions("Abo&ut", self.aboutf, "Ctrl+U", ":/icons/about.png", "About") hlp_visitblog = self.createactions("&Visit Blog", self.visitblogf, "None", ":/icons/visitblog.png", "Visit our blog") hlp_help = self.createactions("&Help", self.helpf, "Ctrl+H", ":/icons/help.png", "Help Contents") #list of help menu items hlp_menu = (hlp_about, hlp_visitblog, hlp_help) #Setting up the menubar filemenu = self.menuBar().addMenu("&File") self.addmenu(filemenu, fi_menu) gomenu = self.menuBar().addMenu("&Go") self.addmenu(gomenu, go_menu) bkmmenu = self.menuBar().addMenu("&Book Mark") self.addmenu(bkmmenu, bkm_menu) helpmenu = self.menuBar().addMenu("&Help") self.addmenu(helpmenu, hlp_menu) intn = QSize(40, 40) self.setIconSize(intn) #Setting up the tool bar filetools = self.addToolBar("File") filetools.setObjectName("filetools") self.addmenu(filetools, (fi_addwrd, fplus, fminus)) gotools = self.addToolBar("Go") gotools.setObjectName("gotools") self.addmenu(gotools, go_menu) bkmtools = self.addToolBar("Bkm") bkmtools.setObjectName("bkmtools") self.addmenu(bkmtools, bkm_menu) hlptools = self.addToolBar("Help") hlptools.setObjectName("helptools") self.addmenu(hlptools, hlp_menu) self.loadfiles() self.returncount = 0 self.bkm_addfav.setEnabled(False) #clipboard function if self.clipauto: clip = QApplication.clipboard() cliptxt = clip.text() self.comboBox.setText(cliptxt) self.setevent() #connections self.connect(self.comboBox, SIGNAL("textChanged(QString)"), self.search) self.connect(self.comboBox, SIGNAL("returnPressed()"), self.returnpressedevent) self.connect(self.searchbtn, SIGNAL("clicked()"), self.onenter) self.connect(self.listview, SIGNAL("itemDoubleClicked(QListWidgetItem*)"), self.listwidcall) self.connect(self.histli, SIGNAL("itemDoubleClicked(QListWidgetItem*)"), self.listwidcall) self.connect(self.bkmli, SIGNAL("itemDoubleClicked(QListWidgetItem*)"), self.listwidcall) def writehistlis(self, lis): if len(lis) >= 2: for i in range(1, len(lis)): cur.execute("insert into HISTORY values(?)", (lis[i], )) def writebkmlis(self, lis): cur.execute("delete from BOOKMARKS") if len(lis) > 0: for i in range(len(lis)): cur.execute("insert into BOOKMARKS values(?)", (lis[i], )) def listwidcall(self, item): self.comboBox.setText(item.text()) self.setevent() def search(self, text, *args): li = [] tplus = text + "%" cur.execute("select ENGW from ENGTAM where ENGW like ? limit 20", (tplus, )) cuf = cur.fetchall() model = QStringListModel() for i in range(len(cuf)): k = cuf[i][0] li.append(k) model.setStringList(li) self.completer.setModel(model) def returnpressedevent(self, *args): self.comboBox.selectAll() self.returncount += 1 if self.returncount % 2 == 0: self.setevent() else: self.comboBox.selectAll() def setevent(self): self.comboBox.selectAll() self.bkm_addfav.setEnabled(True) lis = [] eng = self.comboBox.text() cur.execute("SELECT rowid, TAMW FROM ENGTAM WHERE ENGW like ? limit 1", (eng,)) cuf = cur.fetchall() if len(cuf) == 0: self.tamtext.setText("No words found. . . ") self.listview.addItem("No Suggestions. . .") else: for i in range(len(cuf)): tam = cuf[0][1] rowid = cuf[0][0] self.tamtext.setText(tam) if rowid <= 25: start = 0 end = 50 elif rowid >= 190513: start = rowid - 190487 end = rowid + 190537 else: start = rowid - 25 end = rowid + 25 cur.execute("SELECT ENGW FROM ENGTAM WHERE rowid>=? and rowid<=?", (start, end, )) cuff = cur.fetchall() for i in range(len(cuff)): engw = cuff[i][0] lis.append(engw) if self.listview.count() is not None: self.listview.clear() self.listview.addItems(lis) self.addtoli(eng, self.histlis) if self.histlis[0] >= 2: self.go_prev.setEnabled(True) self.comboBox.setFocus() if self.histdock: self.histli.addItem(eng) def addtoli(self, addw, lis, c=1): if len(lis) > 0: if type(lis[0]) == int: if len(lis) >= 2: for i in range(1, len(lis)): if lis[i] == addw: c = 0 pass if c == 1: lis.append(addw) else: lis.append(addw) lis[0] = len(lis) - 1 def addtobkmli(self, addw, lis, nc=1): for i in range(len(lis)): if lis[i] == addw: nc = 0 pass if nc == 1: lis.append(addw) def onenter(self, *args): self.comboBox.selectAll() self.setevent() def loadfiles(self): self.loadsettings() self.loadhistlis() self.loadbkm() self.setfontsize(int(self.fontsize)) self.setdocks() def setdocks(self): ist = str(self.histdock) jst = str(self.bkmdock) if ist == "False": self.removedock(self.histdockwidg) else: self.adddock(self.histdockwidg) if jst == "False": self.removedock(self.bkmdockwidg) else: self.adddock(self.bkmdockwidg) def loadsettings(self): cur.execute("select * from SETTINGS") cuffun = cur.fetchall() fn = int(cuffun[0][1]) self.fontsize = fn self.clipauto = cuffun[1][1] self.histdock = cuffun[2][1] self.savehist = cuffun[3][1] self.bkmdock = cuffun[4][1] self.delhist = cuffun[5][1] self.delbkm = cuffun[6][1] def loadhistlis(self): histtodockli = [] cur.execute("select * from HISTORY") historyfetch = cur.fetchall() for i in range(len(historyfetch)): self.addtobkmli(historyfetch[i][0], histtodockli) for i in histtodockli: self.histli.addItem(i) def loadbkm(self): cur.execute("select * from BOOKMARKS") bkmfetch = cur.fetchall() for i in range(len(bkmfetch)): self.addtobkmli(bkmfetch[i][0], self.bkmlistfromfile) for i in self.bkmlistfromfile: self.bkmli.addItem(i) def createactions(self, text, slot=None, shortcut="None", icon=None, tip=None, checkable=False, signal="triggered()"): action = QAction(text, self) if icon is not None: action.setIcon(QIcon(icon)) if shortcut is not None: action.setShortcut(shortcut) if tip is not None: action.setToolTip(tip) action.setStatusTip(tip) if slot is not None: self.connect(action, SIGNAL(signal), slot) if checkable: action.setCheckable(True) return action def addmenu(self, target, actions): for action in actions: if action is None: target.addSeparator() else: target.addAction(action) #Actions def addwrdf(self): self.dlg = addawrd() self.dlg.show() self.connect(self.dlg.buttonBox, SIGNAL("rejected()"), self.dlg.close) self.connect(self.dlg.buttonBox, SIGNAL("accepted()"), self.addawordtodb) def addawordtodb(self): eng = self.dlg.lineEdit.text() tam = self.dlg.lineEdit_2.text() if len(eng) != 0 and len(tam) != 0: cur.execute("INSERT INTO ENGTAM(ENGW, TAMW) VALUES(?, ?)", (eng, tam, )) self.dlg.close() QMessageBox.information(self, "Nigandu Eng -> Tam Dictionary", "Added Successfully. . .") else: self.dlg.lineEdit.setFocus() self.dlg.close() QMessageBox.warning(self, "Nigandu Eng -> Tam Dictionary", "Invalid Entry. . .") def optionsf(self): self.opt = optdlg(self) self.opt.spinBox.setProperty("value", int(self.fontsize)) font = QFont() font.setPixelSize(int(self.fontsize)) self.opt.sampletxt.setFont(font) if str(self.clipauto) == "True": self.opt.checkclip.setChecked(True) elif str(self.clipauto) == "False": self.opt.checkclip.setChecked(False) if str(self.histdock) == "True": self.opt.checkshowhistdock.setChecked(True) elif str(self.histdock) == "False": self.opt.checkshowhistdock.setChecked(False) if str(self.bkmdock) == "True": self.opt.checkshowbkmdock.setChecked(True) elif str(self.bkmdock) == "False": self.opt.checkshowbkmdock.setChecked(False) self.opt.show() self.connect(self.opt.buttonBox, SIGNAL("accepted()"), self.optok) self.connect(self.opt.buttonBox.button(QDialogButtonBox.Apply), SIGNAL("clicked()"), self.optapply) self.connect(self.opt.checkdelhist, SIGNAL("stateChanged(int)"), self.deleteallhist) self.connect(self.opt.checkshowhistdock, SIGNAL("stateChanged(int)"), self.shownexttime) self.connect(self.opt.checkshowbkmdock, SIGNAL("stateChanged(int)"), self.shownexttime) def shownexttime(self, i): if i == 0: pass if i == 2: QMessageBox.information(self, self.windowTitle(), "Click Apply or Ok \n The Dock window will be added, \n the next time you start the application. . .") def optok(self): self.optapply() self.opt.close() def optapply(self): self.updatesettings() self.applyopt() def updatesettings(self): self.fontsize = self.opt.spinBox.value() self.clipauto = self.opt.checkclip.isChecked() self.histdock = self.opt.checkshowhistdock.isChecked() self.bkmdock = self.opt.checkshowbkmdock.isChecked() self.delhist = self.opt.checkdelhist.isChecked() for i, j in [("fontsize", self.fontsize),("clipauto", str(self.clipauto)),("histdock", str(self.histdock)), ("bkmdock", str(self.bkmdock)),("delhist", str(self.delhist))]: cur.execute("UPDATE SETTINGS SET setting=? WHERE field=?", (j, i, )) def applyopt(self): self.loadsettings() self.setfontsize(int(self.fontsize)) if str(self.bkmdock) == "False" or str(self.histdock) == "False": self.setdocks() def removedock(self, dock): self.removeDockWidget(dock) def adddock(self, dock): self.addDockWidget(Qt.RightDockWidgetArea, dock) def deleteallhist(self, i): if i == 0: pass elif i == 2: self.histli.clear() self.histlis = [0] cur.execute("delete from HISTORY") QMessageBox.information(self, self.windowTitle(), "All the History Records are deleted. . .") def setfontsize(self, i): if i >= 8 or i <= 24: font = QFont() font.setPixelSize(i) self.comboBox.setFont(font) self.searchbtn.setFont(font) self.bkmli.setFont(font) self.histli.setFont(font) self.listview.setFont(font) self.tamtext.setFont(font) def helpf(self): form = helpform.HelpForm("index.html", self) form.show() def closeEvent(self, *args, **kwargs): self.writehistlis(self.histlis) self.writebkmlis(self.bkmlistfromfile) for i, j in [("fontsize", int(self.fontsize)),("clipauto", str(self.clipauto)),("histdock", str(self.histdock)), ("bkmdock", str(self.bkmdock)),("delhist", str(self.delhist))]: cur.execute("UPDATE SETTINGS SET setting=? WHERE field=?", (j, i, )) con.commit() con.close() def fplusf(self): self.fontsize += 1 if self.fontsize <= 24: self.setfontsize(self.fontsize) def fminusf(self): self.fontsize -= 1 if self.fontsize >= 10: self.setfontsize(self.fontsize) def prevf(self): pr = self.histlis[0] - 1 if pr > 1: self.comboBox.setText(self.histlis[pr]) self.setevent() self.histlis[0] = pr self.go_next.setEnabled(True) elif pr == 1: self.comboBox.setText(self.histlis[pr]) self.setevent() self.histlis[0] = pr self.go_next.setEnabled(True) self.go_prev.setEnabled(False) else: pass def nextf(self): pr = self.histlis[0] + 1 if pr < len(self.histlis) - 1: self.comboBox.setText(self.histlis[pr]) self.setevent() self.histlis[0] = pr self.go_prev.setEnabled(True) elif pr == len(self.histlis) - 1: self.comboBox.setText(self.histlis[pr]) self.setevent() self.histlis[0] = pr self.go_prev.setEnabled(True) self.go_next.setEnabled(False) else: pass def randf(self): import random n = random.randrange(190538) cur.execute("select ENGW from ENGTAM where rowid = ?", (n, )) cuf = cur.fetchone() self.comboBox.setText(cuf[0]) self.setevent() def addfavf(self): txt = self.comboBox.text() if len(txt) != 0: self.addtobkmli(txt, self.bkmlistfromfile) self.writetolistwidget(self.bkmlistfromfile, self.bkmli) def sortit(self): self.bkmlistfromfile.sort() self.writetolistwidget(self.bkmlistfromfile, self.form.listWidget) self.writetolistwidget(self.bkmlistfromfile, self.bkmli) cur.execute("delete from BOOKMARKS") def writetolistwidget(self, lis, liswid): liswid.clear() for i in lis: liswid.addItem(i) def deletecurrentbkm(self): ct = self.form.listWidget.currentItem().text() self.bkmlistfromfile.remove(ct) self.writetolistwidget(self.bkmlistfromfile, self.bkmli) self.writetolistwidget(self.bkmlistfromfile, self.form.listWidget) cur.execute("delete from BOOKMARKS") def deleteallbkm(self): self.form.listWidget.clear() self.bkmli.clear() self.bkmlistfromfile = [] cur.execute("delete from BOOKMARKS") def viewbkmf(self): self.form = managebkm(self) self.writetolistwidget(self.bkmlistfromfile, self.form.listWidget) self.form.show() self.connect(self.form.closebtn, SIGNAL("clicked()"), self.form.close) self.connect(self.form.sortbtn, SIGNAL("clicked()"), self.sortit) self.connect(self.form.deletebtn, SIGNAL("clicked()"), self.deletecurrentbkm) self.connect(self.form.deleteallbtn, SIGNAL("clicked()"), self.deleteallbkm) def aboutf(self): QMessageBox.about(self, "About Nigandu English to Tamil Dictionary", """<b>Nigandu English to Tamil Dictionary</b> v %s <p>This is the first corss-platform English to Tamil bilingual dictionary; Free to use.</p> <p>Copyright © 2014 NJN Private Ltd. All rights reserved.</p> <p>Thanks to Python and PySide Project.</p> <p>Using Python 3.3, Qt 4.8 and PySide 1.2.1</p>""" % (__version__)) def visitblogf(self): webbrowser.open("http://www.e-nool.blogspot.com")
class EditorCodeCompletion(QTextEdit): def __init__(self, path_dict): super(EditorCodeCompletion, self).__init__() self.m_completer = QCompleter(self) self.m_completer.setWidget(self) words = [] self.flag_open_angle_bracket = False self.tag_name = "" try: f = open(path_dict,"r") for word in f: words.append(word.strip()) f.close() except IOError: print ("dictionary not in anticipated location") model = QStringListModel(words, self.m_completer) self.m_completer.setModel(model) self.m_completer.setCompletionMode(QCompleter.PopupCompletion) self.m_completer.activated.connect(self.insertCompletion) def insertCompletion (self, completion): cursor = self.textCursor() cursor.beginEditBlock() cursor.movePosition(QTextCursor.Left) cursor.movePosition(QTextCursor.EndOfWord) extra = len(self.m_completer.completionPrefix()) cursor.insertText(completion[extra:]) self.setTextCursor(cursor) cursor.endEditBlock() def __insertTag(self): ''' inserts the corresponding closing tag to an opening xml tag ''' self.find('<', QTextDocument.FindBackward) tc = self.textCursor() tc.select(QTextCursor.WordUnderCursor) txt = '' if self.__stringHasBracket(tc.selectedText().replace(' ', '')) else tc.selectedText() txt = '</' + txt + '>' self.find('>') tc = self.textCursor() tc.clearSelection() tc.insertText(txt) tc.movePosition(QTextCursor.Left, QTextCursor.MoveAnchor, len(txt)) self.setTextCursor(tc) def __stringHasBracket(self, s): return '<' in s or '>' in s def __insertClosingTag(self, event): operation_sys = sys.platform flag = "linux" in operation_sys if flag : self.__insertClosingTag_Unix(event) else: self.__insertClosingTag_Win(event) def __insertClosingTag_Unix(self, event): ''' inserts a closing tag after the closing bracket of open tag @param key: keyboard input value as int ''' if self.flag_open_angle_bracket : if event.key() == 47 : # / print ("/") self.flag_open_angle_bracket = False elif event.key() == 62 : # > print (">") self.__insertTag() self.flag_open_angle_bracket = False elif event.key() == 60 : # < print ("<") self.flag_open_angle_bracket = True def __insertClosingTag_Win(self, event) : if self.flag_open_angle_bracket : if event.modifiers() & Qt.ShiftModifier : if event.key() == 55 : # / print ("/") self.flag_open_angle_bracket = False elif event.key() == 60 : # > print (">") self.__insertTag() self.flag_open_angle_bracket = False elif event.key() == 60 : # < print ("<") self.flag_open_angle_bracket = True def keyPressEvent(self, event): ''' checks keyboard input to set closing tag or start code completion ''' if self.m_completer.popup().isVisible() : if event.key() == Qt.Key_Enter or event.key() == Qt.Key_Return or event.key() == Qt.Key_Tab or event.key() == Qt.Key_Escape : event.ignore() return # open popup isShortcut = (event.modifiers() == Qt.ControlModifier and event.key() == Qt.Key_Space) if not isShortcut: super(EditorCodeCompletion, self).keyPressEvent(event) # ============================================================================================= # begin tag inline insertion self.__insertClosingTag(event) # end tag inline insertion # ============================================================================================= cursor = self.textCursor() cursor.select(QTextCursor.WordUnderCursor) completionPrefix = cursor.selectedText() if completionPrefix != self.m_completer.completionPrefix() : self.m_completer.setCompletionPrefix(completionPrefix) self.m_completer.popup().setCurrentIndex(self.m_completer.completionModel().index(0, 0)) # if not event.text() != "" and len(completionPrefix) > 2 : if len(completionPrefix) > 2 and isShortcut : print ("hier") cr = self.cursorRect() cr.setWidth(2 * (self.m_completer.popup().sizeHintForColumn(0) + self.m_completer.popup().verticalScrollBar().sizeHint().width())) self.m_completer.complete(cr) # # popup it up!