def __setUpInputOutputLayout(self) -> QFormLayout:
# Add input and output boxes
self._inputComboBox = QComboBox(self.editor)
self._inputComboBox.setModel(self.operation.workbench)
self._outputNameBox = TextOptionWidget(parent=self.editor)
self._outputNameBox.widget.textChanged.connect(
self._validateOutputName)
self._inputComboBox.currentTextChanged.connect(self._changeInputFrame)
ioLayout = QFormLayout()
ioLayout.addRow('Input data:', self._inputComboBox)
ioLayout.addRow('Output name:', self._outputNameBox)
completer = QCompleter(self._outputNameBox)
completer.setModel(self.operation.workbench)
completer.setFilterMode(Qt.MatchContains)
completer.setModelSorting(QCompleter.CaseInsensitivelySortedModel)
completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self._outputNameBox.widget.setCompleter(completer)
if self.selectedFrame:
if self.selectedFrame == self._inputComboBox.currentText():
# Manually trigger the slot to change input
self._changeInputFrame(self.selectedFrame)
else:
# Set the frame (will trigger _changeInputFrame)
self._inputComboBox.setCurrentText(self.selectedFrame)
else:
# Default to whatever input name is set
self._changeInputFrame(self._inputComboBox.currentText())
return ioLayout
class QFilteredComboBox(QComboBox):
def __init__(
self,
parent=None,
include_targets=True,
include_airbases=True,
include_frontlines=True,
include_units=True,
include_enemy=True,
include_friendly=True,
):
super(QFilteredComboBox, self).__init__(parent)
self.setFocusPolicy(Qt.StrongFocus)
self.setEditable(True)
self.completer = QCompleter(self)
self.include_targets = include_targets
self.include_airbases = include_airbases
self.include_frontlines = include_frontlines
self.include_units = include_units
self.include_enemy = include_enemy
self.include_friendly = include_friendly
# 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(QFilteredComboBox, self).setModel(model)
self.pFilterModel.setSourceModel(model)
self.completer.setModel(self.pFilterModel)
self.model().sort(0)
def setModelColumn(self, column):
self.completer.setCompletionColumn(column)
self.pFilterModel.setFilterKeyColumn(column)
super(QFilteredComboBox, 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)
def load(self) -> None:
"""opens json file and loads its content into registered devices
Returns:
None"""
self.model.clear()
self.registered_devices.clear()
with open(self.file_path, "r") as file:
data = dict(json.load(file))
devices = data["devices"].values()
self.last_open_file_dir = data["last_open_file_dir"]
for value in devices:
row = []
for i, item in enumerate(value):
cell = QStandardItem(str(item))
row.append(cell)
if i == 0 or i == 3 or i == 5:
cell.setEditable(False)
self.model.appendRow(row)
new = [x for x in valid_devices
if x.__name__ == value[3]].pop(0)(value[0], value[1],
value[4], value[5])
new.OS = value[2]
self.registered_devices[value[0]] = new
self.model.setHorizontalHeaderLabels(labels)
self.statusbar.showMessage("")
# auto complete
for a in range(len(self.header.editors)):
completer = QCompleter([
self.model.data(self.model.index(x, a))
for x in range(self.model.rowCount())
])
completer.setCompletionMode(QCompleter.InlineCompletion)
self.header.editors[a].setCompleter(completer)
class AdvComboBox(QComboBox):
"""
Combo with autocomplete
Found in Internet by Sergei
"""
def __init__(self, parent=None):
super(AdvComboBox, self).__init__(parent)
self.setFocusPolicy(QtCore.Qt.StrongFocus)
self.setEditable(True)
# add a filter model to filter matching items
self.pFilterModel = QSortFilterProxyModel(self)
self.pFilterModel.setFilterCaseSensitivity(QtCore.Qt.CaseInsensitive)
self.pFilterModel.setSourceModel(self.model())
# add a completer, which uses the filter model
self.completer = QCompleter(self.pFilterModel, self)
# always show all (filtered) completions
self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.setCompleter(self.completer)
# connect signals
def filter_function(text):
self.pFilterModel.setFilterFixedString(str(text))
self.lineEdit().textEdited.connect(filter_function)
self.completer.activated.connect(self.on_completer_activated)
# on selection of an item from the completer, select the corresponding item from combobox
def on_completer_activated(self, text):
if text:
index = self.findText(str(text))
self.setCurrentIndex(index)
class PMGListCtrl(BaseExtendedWidget):
def __init__(self,
layout_dir: str,
title: str,
initial_value: List[List[str]],
new_id_func: Callable = None):
super().__init__(layout_dir)
self.choices = []
self.text_list = []
lab_title = QLabel(text=title)
layout = QHBoxLayout()
self.central_layout.addWidget(lab_title)
self.on_check_callback = None
self.list_widget = QListWidget()
self.list_widget.mouseDoubleClickEvent = self.on_listwidget_double_cicked
self.set_value(initial_value)
layout_tools = QVBoxLayout()
self.button_add_item = QPushButton('+')
self.button_delete_item = QPushButton('-')
self.button_delete_item.clicked.connect(self.delete_row)
self.button_add_item.clicked.connect(self.add_row)
self.button_add_item.setMaximumWidth(20)
self.button_delete_item.setMaximumWidth(20)
layout_tools.addWidget(self.button_add_item)
layout_tools.addWidget(self.button_delete_item)
layout.addLayout(layout_tools)
layout.addWidget(self.list_widget)
self.central_layout.addLayout(layout)
self.data = initial_value
self.new_id_func = new_id_func
self.text_edit = QLineEdit(parent=self.list_widget)
self.text_edit.setWindowFlags(self.text_edit.windowFlags() | Qt.Dialog
| Qt.FramelessWindowHint)
self.text_edit.hide()
self.completer = QCompleter()
self.text_edit.setCompleter(self.completer)
self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
def set_completions(self, completions: List[str]):
"""
设置补全内容
Args:
completions:
Returns:
"""
self.completer.setModel(QStringListModel(completions))
def new_id(self):
if callable(self.new_id_func):
return self.new_id_func()
else:
return None
def add_row(self):
self.data = self.get_value()
self.data[0].append(self.new_id())
self.data[1].append('Unnamed')
self.list_widget.addItem(QListWidgetItem('Unnamed'))
def delete_row(self):
index = self.list_widget.currentIndex().row()
self.data[0].pop(index)
self.data[1].pop(index)
self.list_widget.takeItem(index)
def on_listwidget_double_cicked(self, evt: QMouseEvent):
print('edit', evt)
pos = evt.globalPos()
current_item: QListWidgetItem = self.list_widget.currentItem()
def set_value():
current_item.setText(self.text_edit.text())
self.text_edit.hide()
self.text_edit.returnPressed.disconnect(set_value)
item: QListWidgetItem = self.list_widget.currentItem()
self.text_edit.setGeometry(pos.x(), pos.y(), 200, 20)
self.text_edit.returnPressed.connect(set_value)
self.text_edit.show()
# self.list_widget.editItem(item)
def get_value(self):
text = []
for i in range(self.list_widget.count()):
text.append(self.list_widget.item(i).text())
self.data[1] = text
assert len(self.data[1]) == len(self.data[0]), repr(self.data)
return self.data
def set_value(self, data: List[List[str]]):
self.list_widget.clear()
self.list_widget.addItems(data[1])
self.data = data
for index in range(self.list_widget.count()):
item: QListWidgetItem = self.list_widget.item(index)
class SearchEdit(QLineEdit):
def __init__(self, parent: QWidget):
QLineEdit.__init__(self, parent)
self.completer = None
def init_completer(self, words: Iterable[str]) -> None:
assert self.completer is None
self.completer = QCompleter(list(words), self)
self.completer.setWidget(self)
self.completer.setCompletionMode(QCompleter.PopupCompletion)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.completer.activated.connect(self.on_insert_completion)
def completer(self) -> QCompleter:
return self.completer
def on_insert_completion(self, completion):
if self.completer.widget() != self:
return
prefix = self.completer.completionPrefix()
extra_text = completion[len(prefix):] + ', '
self.insert(extra_text)
def text_under_cursor(self) -> str:
text = self.text()
cursor_pos = self.cursorPosition()
start_index = None
comma_index1 = text[:cursor_pos].rfind(',')
if comma_index1 >= 0:
start_index = comma_index1 + 1
end_index = None
comma_index2 = text[cursor_pos:].find(',')
if comma_index2 >= 0:
end_index = cursor_pos + comma_index2
return text[start_index:end_index].strip()
def focus_in_event(self, event: QFocusEvent) -> None:
if self.completer:
self.completer.setWidget(self)
QLineEdit.focusInEvent(self, event)
def keyPressEvent(self, key_event: QKeyEvent) -> None:
if self.completer and self.completer.popup().isVisible():
# The following keys are forwarded by the completer to the widget
key = key_event.key()
if key in (Qt.Key_Enter, Qt.Key_Return, Qt.Key_Escape, Qt.Key_Tab,
Qt.Key_Backtab):
key_event.ignore()
return # let the completer do default behavior
is_ctrl_modifier = (key_event.modifiers() & Qt.ControlModifier) != 0
is_shift_modifier = (key_event.modifiers() & Qt.ShiftModifier) != 0
ctrl_or_shift = is_ctrl_modifier or is_shift_modifier
is_shortcut = is_ctrl_modifier and key_event.key(
) == Qt.Key_E # CTRL+E
if not self.completer or not is_shortcut: # do not process the shortcut when we have a completer
QLineEdit.keyPressEvent(self, key_event)
if not self.completer or ctrl_or_shift and key_event.text() == '':
return
eow = "~!@#$%^&*()_+{}|:\"<>?,./;'[]\\-=" # end of word
has_modifier = (key_event.modifiers() !=
Qt.NoModifier) and not ctrl_or_shift
completion_prefix = self.text_under_cursor()
if not is_shortcut:
event_text = key_event.text()
if has_modifier or not event_text or len(
completion_prefix) < 1 or event_text[-1] in eow:
self.completer.popup().hide()
return
if completion_prefix != self.completer.completionPrefix():
self.completer.setCompletionPrefix(completion_prefix)
self.completer.popup().setCurrentIndex(
self.completer.completionModel().index(0, 0))
cr = self.cursorRect()
cr.setWidth(
self.completer.popup().sizeHintForColumn(0) +
self.completer.popup().verticalScrollBar().sizeHint().width())
self.completer.complete(cr) # popup it up!
class ExtendedComboBox(QComboBox):
def __init__(self, parent=None):
super(ExtendedComboBox, self).__init__(parent)
#self.setFocusPolicy(Qt.StrongFocus)
#self.setSizeAdjustPolicy(QComboBox.AdjustToContents)
# self.setStyleSheet('''
#QComboBox { min-width: 1px}
#QComboBox QAbstractItemView::item { min-width: 200px;}"
#''')
self.setEditable(True)
self.setVisible(True)
# add a filter model to filter matching items
self.pFilterModel = QSortFilterProxyModel(self)
self.pFilterModel.setFilterCaseSensitivity(Qt.CaseInsensitive)
self.pFilterModel.setSourceModel(self.model())
# add a completer, which uses the filter model
self.completer = QCompleter(self.pFilterModel, self)
# always show all (filtered) completions
self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.setCompleter(self.completer)
# connect signals
self.lineEdit().textEdited.connect(
self.pFilterModel.setFilterFixedString)
self.completer.activated.connect(self.on_completer_activated)
# on selection of an item from the completer, select the corresponding item from combobox
def on_completer_activated(self, text):
if text:
index = self.findText(text)
self.setCurrentIndex(index)
self.activated[str].emit(self.itemText(index))
# on model change, update the models of the filter and completer as well
def setModel(self, model):
super(ExtendedComboBox, self).setModel(model)
self.pFilterModel.setSourceModel(model)
self.completer.setModel(self.pFilterModel)
# on model column change, update the model column of the filter and completer as well
def setModelColumn(self, column):
self.completer.setCompletionColumn(column)
self.pFilterModel.setFilterKeyColumn(column)
super(ExtendedComboBox, self).setModelColumn(column)
#if __name__ == "__main__":
# app = QApplication(sys.argv)
# string_list = ['hola muchachos', 'adios amigos', 'hello world', 'good bye']
# combo = ExtendedComboBox()
# # either fill the standard model of the combobox
# combo.addItems(string_list)
# # or use another model
# #combo.setModel(QStringListModel(string_list))
# combo.resize(300, 40)
# combo.show()
# sys.exit(app.exec_())
class ExtendedComboBox(QComboBox):
def __init__(self, table_name="", update_field="", database=None, parent=None):
super(ExtendedComboBox, self).__init__(parent)
self.__type = Types.TEXT
self.setMinimumHeight(30)
self.setFocusPolicy(Qt.StrongFocus)
self.setEditable(True)
self._table_name = table_name
self._update_field = update_field
self._database = database
# add a filter model to filter matching items
self.pFilterModel = QSortFilterProxyModel(self)
self.pFilterModel.setFilterCaseSensitivity(Qt.CaseInsensitive)
self.pFilterModel.setSourceModel(self.model())
# add a completer, which uses the filter model
self.completer = QCompleter(self.pFilterModel, self)
# always show all (filtered) completions
self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.setCompleter(self.completer)
# connect signals
self.lineEdit().textEdited.connect(self.pFilterModel.setFilterFixedString)
self.completer.activated.connect(self.on_completer_activated)
def setDatabase(self, database):
self._database = database
def getType(self):
return self.__type
# on selection of an item from the completer, select the corresponding item from combobox
def on_completer_activated(self, text):
if text:
index = self.findText(text)
self.setCurrentIndex(index)
self.activated[str].emit(self.itemText(index))
# on model change, update the models of the filter and completer as well
def setModel(self, model):
super(ExtendedComboBox, self).setModel(model)
self.pFilterModel.setSourceModel(model)
self.completer.setModel(self.pFilterModel)
# on model column change, update the model column of the filter and completer as well
def setModelColumn(self, column):
self.completer.setCompletionColumn(column)
self.pFilterModel.setFilterKeyColumn(column)
super(ExtendedComboBox, self).setModelColumn(column)
def updateListValues(self):
if self._update_field and self._database != None:
self.clear()
self._database.openDatabase()
items = list(set(self._database.getValuesFromField(self._table_name, self._update_field)))
self._database.closeDatabase()
self.addItems(items)
def setValue(self, value):
if self._update_field and self._table_name and self._database != None:
self.updateListValues()
index = self.findText(value)
if index == -1:
self.setCurrentIndex(0)
else:
self.setCurrentIndex(index)
def getValue(self):
return self.currentText()
def clearValue(self):
self.setCurrentIndex(0)
def connectFunction(self, function):
self.activated.connect(function)
def __init__(self, parent=None):
super(myWindow, self).__init__(parent)
clicked = QtCore.Signal()
self.primed = 0
self.pointer = None
self.histlist = []
self.HIST_SIZE = 10
self.tb = self.addToolBar("File")
self.tb.setMovable(False)
self.tb.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)
self.tb.actionTriggered[QAction].connect(self.toolbtnpressed)
self.previous = QAction(QIcon("./imgs/56.png"), "Previous", self)
self.tb.addAction(self.previous)
self.next = QAction(QIcon("./imgs/57.png"), "Next", self)
self.tb.addAction(self.next)
self.options = QAction(QIcon("./imgs/46.png"), "Options", self)
self.tb.addAction(self.options)
self.about = QAction(QIcon("./imgs/48.png"), "About", self)
self.about.triggered.connect(self._show_about)
self.tb.addAction(self.about)
if (self.pointer is None):
self.previous.setEnabled(False)
self.next.setEnabled(False)
wdg = QWidget(self)
wdg.setMinimumSize(460, 460)
glayout = QGridLayout()
self.setMinimumSize(600, 600)
self.le = ClickableLineEdit(wdg)
self.le.setStyleSheet('color:maroon;font-size: 14px;')
self.le.setObjectName("searchword")
self.le.setText("Enter word to Search...!")
self.le.clicked.connect(self.le.clear)
self.wordlist = []
self.loadwords()
completer = QCompleter(self.wordlist, self.le)
completer.setCompletionMode(completer.PopupCompletion)
self.le.setCompleter(completer)
self.pb = QPushButton(wdg)
self.pb.setObjectName("go")
self.pb.setText("தேடு")
self.pb.setStyleSheet(
'color: #0077CC; font-weight:bold; font-size: 14px;')
self.te = QTextEdit(wdg)
self.te.setLineWrapMode(QTextEdit.NoWrap)
self.sbar = QStatusBar()
self.sbar.setStyleSheet('color:maroon;')
self.sbar.showMessage('Ready...!')
glayout.addWidget(QLabel("Find ", self), 1, 1)
glayout.addWidget(self.le, 1, 2)
glayout.addWidget(self.pb, 1, 3)
glayout.addWidget(self.te, 2, 1, 1, 3)
glayout.addWidget(self.sbar, 3, 1, 1, 3)
wdg.setLayout(glayout)
self.setWindowTitle("Power Tamil Dictionary")
app_icon = QtGui.QIcon()
app_icon.addFile('./imgs/PT-Icon.png', QtCore.QSize(16, 16))
self.setWindowIcon(app_icon)
self.connect(self.pb, SIGNAL("clicked()"), self.button_click)
self.le.returnPressed.connect(self.pb.click)
self.hotkey = {}
self.hotkey['my_key'] = QShortcut(QtGui.QKeySequence("Ctrl+E"), self)
self.hotkey['my_key'].activated.connect(self.animate_click)
self.te.selectionChanged.connect(self.handleSelectionChanged)
self.setCentralWidget(wdg)