def _completerSetupFunction(self, editor, index):
completer = QCompleter(getHeadersData(), editor)
completer.setCompletionColumn(0)
completer.setCompletionRole(Qt.EditRole)
completer.setCaseSensitivity(Qt.CaseInsensitive)
try:
editor.setCompleter(completer)
except:
pass
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)
class AbstractReferenceSelector(ABC, QWidget, metaclass=SelectorMeta):
changed = Signal()
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.completer = None
self.p_selected_id = 0
self.layout = QHBoxLayout()
self.layout.setMargin(0)
self.name = QLineEdit()
self.name.setText("")
self.layout.addWidget(self.name)
self.details = QLabel()
self.details.setText("")
self.details.setVisible(False)
self.layout.addWidget(self.details)
self.button = QPushButton("...")
self.button.setFixedWidth(self.button.fontMetrics().width("XXXX"))
self.layout.addWidget(self.button)
self.setLayout(self.layout)
self.setFocusProxy(self.name)
self.button.clicked.connect(self.on_button_clicked)
if self.details_field:
self.name.setFixedWidth(self.name.fontMetrics().width("X") * 15)
self.details.setVisible(True)
self.completer = QCompleter(self.dialog.model.completion_model)
self.completer.setCompletionColumn(
self.dialog.model.completion_model.fieldIndex(self.selector_field))
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.name.setCompleter(self.completer)
self.completer.activated[QModelIndex].connect(self.on_completion)
def getId(self):
return self.p_selected_id
def setId(self, selected_id):
if self.p_selected_id == selected_id:
return
self.p_selected_id = selected_id
self.name.setText(
self.dialog.model.getFieldValue(selected_id, self.selector_field))
if self.details_field:
self.details.setText(
self.dialog.model.getFieldValue(selected_id,
self.details_field))
selected_id = Property(int, getId, setId, notify=changed, user=True)
def on_button_clicked(self):
ref_point = self.mapToGlobal(self.name.geometry().bottomLeft())
self.dialog.setGeometry(ref_point.x(), ref_point.y(),
self.dialog.width(), self.dialog.height())
res = self.dialog.exec_(enable_selection=True,
selected=self.selected_id)
if res:
self.selected_id = self.dialog.selected_id
self.changed.emit()
@Slot(QModelIndex)
def on_completion(self, index):
model = index.model()
self.selected_id = model.data(model.index(index.row(), 0),
Qt.DisplayRole)
self.changed.emit()
def isCustom(self):
return True
class BrowserWidget(QWidget):
"""
This class puts together a TabCompletionLineEdit and a list view of teh FolderListModel in one single widget.
"""
activated = Signal(str) # emitted when the user selects a file
def __init__(self, parent=None):
super().__init__(parent)
self._recursiveActivated = False
self._model = FolderListModel(self)
self._completer = QCompleter(self._model, self)
self._completer.setCompletionColumn(3)
self._lineedit = TabCompletionLineEdit(self._completer, self)
self._view = QTreeView(self)
self._view.setModel(self._model)
self._model.folderChanged.connect(self._lineedit.setText)
self._model.setFolder(".")
self._view.header().setSectionResizeMode(0, QHeaderView.Interactive)
self._view.header().setSectionResizeMode(1,
QHeaderView.ResizeToContents)
self._view.header().setSectionResizeMode(2,
QHeaderView.ResizeToContents)
self._view.header().resizeSection(0, 500)
self._view.header().setSectionHidden(3, True)
layout = QVBoxLayout(self)
layout.addWidget(self._lineedit)
layout.addWidget(self._view)
self.setLayout(layout)
self._view.activated.connect(self._activated)
self.activated.connect(self._lineedit.setText)
self._lineedit.returnPressed.connect(self._leActivated,
Qt.QueuedConnection)
self._lineedit.textEdited.connect(self._leTextEdited)
def setActive(self, activeFile):
"""
set the activated file
:param activeFile: a string or Path instance
:return:
"""
activeFile = Path(activeFile)
assert activeFile.is_file()
self._model.setFolder(activeFile.parent)
idx = self._model.fileToIndex(activeFile)
self._view.setCurrentIndex(idx)
self._view.scrollTo(idx)
self.activated.emit(str(activeFile))
def active(self):
"""
The currently activated file
:return: a string instance
"""
cidx = self._view.currentIndex()
c = self._model.data(cidx, Qt.UserRole)
return str(c) if c is not None else None
def current(self):
"""
A synonym for active()
:return: a string instance
"""
return self.active()
def setFilter(self, flt):
"""
Set the name filter of the file browser
:param flt: a string instance or a list of strings
:return:
"""
self._model.setFilter(flt)
def scrollTo(self, item):
"""
Scrolls to the given item.
:param item: a string instance
:return:
"""
cidx = self._model.fileToIndex(item)
self._view.scrollTo(cidx)
def folder(self):
"""
Returns the current folder
:return: a Path instance
"""
return self._model.folder()
def setFolder(self, folder):
"""
Sets the current folder
:param folder: a string or a Path instance
:return:
"""
self._model.setFolder(folder)
def _leActivated(self):
idx = self._model.fileToIndex(self._lineedit.text())
self._activated(idx)
def _leTextEdited(self, text):
p = Path(text)
if p.is_dir() and len(text) > 0 and text[-1] in ["/", "\\"]:
self.setFolder(p)
def _activated(self, idx):
c = self._model.data(idx, Qt.UserRole)
if c is None:
return
logger.debug("activate %s", c)
if c.is_file():
self.activated.emit(str(c))
else:
self._model.setFolder(c)
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)