def __init__(self, app, *args, **kwargs):
super().__init__(app.mainwin, *args, **kwargs)
# Set up the user interface from Designer.
self.setupUi(self)
self.created_dt.setCalendarPopup(True)
# auto-completion set up
self.name_completer = QCompleter(app.patches, self.name_entry)
self.name_completer.setCompletionColumn(0)
self.name_completer.setCaseSensitivity(Qt.CaseInsensitive)
self.name_entry.setCompleter(self.name_completer)
self.shortname_completer = QCompleter(app.patches,
self.shortname_entry)
self.shortname_completer.setCompletionColumn(1)
self.shortname_completer.setCaseSensitivity(Qt.CaseInsensitive)
self.shortname_entry.setCompleter(self.shortname_completer)
self.author_model = AuthorListModel(app.session)
self.author_cb.setModel(self.author_model)
self.author_cb.setModelColumn(2)
self.manufacturer_model = ManufacturerListModel(app.session)
self.manufacturer_cb.setModel(self.manufacturer_model)
self.manufacturer_cb.setModelColumn(3)
self.device_model = DeviceListModel(app.session)
self.device_cb.setModel(self.device_model)
self.device_cb.setModelColumn(3)
self._last_author = None
class QColorLineEdit(QLineEdit):
"""A LineEdit that takes hex, rgb, or autocompletes common color names.
Parameters
----------
parent : QWidget, optional
The parent widget, by default None
"""
def __init__(self, parent=None):
super().__init__(parent)
self._compl = QCompleter(list(get_color_dict()) + ['transparent'])
self._compl.setCompletionMode(QCompleter.InlineCompletion)
self.setCompleter(self._compl)
self.setTextMargins(2, 2, 2, 2)
def setText(self, color: ColorType):
"""Set the text of the lineEdit using any ColorType.
Colors will be converted to standard SVG spec names if possible,
or shown as #RGBA hex if not.
Parameters
----------
color : ColorType
Can be any ColorType recognized by our
utils.colormaps.standardize_color.transform_color function.
"""
_rgb = transform_color(color)[0]
_hex = rgb_to_hex(_rgb)[0]
super().setText(hex_to_name.get(_hex, _hex))
def __init__(self, mask_names):
"""
:type mask_names: set
:param mask_names: iterable collection of all available mask names
"""
super().__init__()
self.mask_names = mask_names
completer = QCompleter(list(mask_names))
completer.setCaseSensitivity(Qt.CaseInsensitive)
self.setWindowTitle("Masks name choose")
self.mask1_name = QLineEdit()
self.mask2_name = QLineEdit()
self.cancel_btn = QPushButton("Cancel")
self.ok_btn = QPushButton("Ok")
self.mask1_name.setCompleter(completer)
self.mask1_name.textChanged.connect(self.text_changed)
self.mask2_name.setCompleter(completer)
self.mask2_name.textChanged.connect(self.text_changed)
self.cancel_btn.clicked.connect(self.close)
self.ok_btn.clicked.connect(self.accept)
self.ok_btn.setDisabled(True)
layout = QGridLayout()
layout.addWidget(right_label("Mask 1 name:"), 0, 0)
layout.addWidget(self.mask1_name, 0, 1)
layout.addWidget(right_label("Mask 2 name:"), 1, 0)
layout.addWidget(self.mask2_name, 1, 1)
layout.addWidget(self.cancel_btn, 2, 0)
layout.addWidget(self.ok_btn, 2, 1)
self.setLayout(layout)
class SearchComboBox(QComboBox):
"""
ComboCox with completer for fast search in multiple options
"""
if parse(QT_VERSION) < parse("5.14.0"):
textActivated = Signal(str) # pragma: no cover
def __init__(self, parent=None):
super().__init__(parent)
self.setEditable(True)
self.completer_object = QCompleter()
self.completer_object.setCaseSensitivity(Qt.CaseInsensitive)
self.completer_object.setCompletionMode(QCompleter.PopupCompletion)
self.completer_object.setFilterMode(Qt.MatchContains)
self.setCompleter(self.completer_object)
self.setInsertPolicy(QComboBox.NoInsert)
if parse(QT_VERSION) < parse("5.14.0"): # pragma: no cover
self.currentIndexChanged.connect(self._text_activated)
def _text_activated(self): # pragma: no cover
self.textActivated.emit(self.currentText())
def addItem(self, *args):
super().addItem(*args)
self.completer_object.setModel(self.model())
def addItems(self, *args):
super().addItems(*args)
self.completer_object.setModel(self.model())
def __init__(self, parent=None):
super(AbstractComboListInputWidget, self).__init__(parent)
self.main_widget = self.parent()
self.previous_text = ''
self.setExistsFlag(True)
# setup line edit
#self.line_edit = QLineEdit("Select & Focus", self)
self.line_edit = QLineEdit(self)
self.line_edit.editingFinished.connect(self.userFinishedEditing)
self.setLineEdit(self.line_edit)
self.setEditable(True)
# setup completer
self.completer = QCompleter(self)
self.completer.setCompletionMode(QCompleter.PopupCompletion)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.completer.setPopup(self.view())
self.setCompleter(self.completer)
self.pFilterModel = QSortFilterProxyModel(self)
# set size policy ( this will ignore the weird resizing effects)
size_policy = QSizePolicy(QSizePolicy.Ignored, QSizePolicy.Preferred)
self.setSizePolicy(size_policy)
# initialize model...
model = QStandardItemModel()
self.setModel(model)
self.setModelColumn(0)
def __init__(self, text="Enter object label", parent=None, listItem=None):
super(LabelDialog, self).__init__(parent)
self.edit = QLineEdit()
self.edit.setText(text)
self.edit.setValidator(self.label_validator())
self.edit.editingFinished.connect(self.post_process)
model = QStringListModel()
model.setStringList(listItem)
completer = QCompleter()
completer.setModel(model)
self.edit.setCompleter(completer)
layout = QVBoxLayout()
layout.addWidget(self.edit)
self.buttonBox = bb = BB(BB.Ok | BB.Cancel, Qt.Horizontal, self)
bb.button(BB.Ok).setIcon(QIcon('icons/done.png'))
bb.button(BB.Cancel).setIcon(QIcon('icons/undo.png'))
bb.accepted.connect(self.validate)
bb.rejected.connect(self.reject)
layout.addWidget(bb)
if listItem is not None and len(listItem) > 0:
self.listWidget = QListWidget(self)
for item in listItem:
self.listWidget.addItem(item)
self.listWidget.itemClicked.connect(self.listItemClick)
self.listWidget.itemDoubleClicked.connect(self.listItemDoubleClick)
layout.addWidget(self.listWidget)
self.setLayout(layout)
def __init__(self, wordlist, *args):
QLineEdit.__init__(self, *args)
self.mycompleter = QCompleter(wordlist)
self.mycompleter.setCaseSensitivity(Qt.CaseInsensitive)
self.mycompleter.setWidget(self)
self.textChanged.connect(self.text_changed)
self.mycompleter.activated.connect(self.complete_text)
def __init__(self, parent=None):
super().__init__(parent)
self.setEditable(True)
self.completer_object = QCompleter()
self.completer_object.setCaseSensitivity(Qt.CaseInsensitive)
self.setCompleter(self.completer_object)
# FIXME
if parse(QT_VERSION) < parse("5.14.0"): # pragma: no cover
self.currentIndexChanged.connect(self._text_activated)
def __init__(self, parent=None):
super().__init__(parent)
self.setEditable(True)
self.completer_object = QCompleter()
self.completer_object.setCaseSensitivity(Qt.CaseInsensitive)
self.completer_object.setCompletionMode(QCompleter.PopupCompletion)
self.completer_object.setFilterMode(Qt.MatchContains)
self.setCompleter(self.completer_object)
self.setInsertPolicy(QComboBox.NoInsert)
if parse(QT_VERSION) < parse("5.14.0"): # pragma: no cover
self.currentIndexChanged.connect(self._text_activated)
def __init__(self, items, parent=None):
super(AutoCompleteLineEdit, self).__init__(parent)
self._separators = [",", " "]
self._completer = QCompleter(items, self)
self._completer.setWidget(self)
self._completer.activated[str].connect(self.__insertCompletion)
self._completer.setCaseSensitivity(Qt.CaseInsensitive)
self.__keysToIgnore = [Qt.Key_Enter, Qt.Key_Return, Qt.Key_Escape, Qt.Key_Tab]
def init_completion_list(self, words):
self.completer = QCompleter(words, self)
self.completer.setCompletionPrefix(self.parent().input_buffer())
self.completer.setWidget(self.parent().edit)
self.completer.setCaseSensitivity(Qt.CaseSensitive)
self.completer.setModelSorting(QCompleter.CaseSensitivelySortedModel)
if self.mode == COMPLETE_MODE.DROPDOWN:
self.completer.setCompletionMode(QCompleter.PopupCompletion)
self.completer.activated.connect(self.insert_completion)
else:
self.completer.setCompletionMode(QCompleter.InlineCompletion)
def _complete_options(self):
"""Find available completion options."""
text = to_text_string(self.currentText())
opts = glob.glob(text + "*")
opts = sorted([opt for opt in opts if osp.isdir(opt)])
completer = QCompleter(opts, self)
qss = str(APP_STYLESHEET)
completer.popup().setStyleSheet(qss)
self.setCompleter(completer)
return opts
def __init__(self, appdata: CnaData, centralwidget: CentralWidget):
QDialog.__init__(self)
self.setWindowTitle("Yield optimization")
self.appdata = appdata
self.centralwidget = centralwidget
self.eng = appdata.engine
self.linear_re = re.compile(
r'([ ]*(?P<factor1>[-]?\d*)[ ]*[*]?[ ]*(?P<reac_id>[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVW]+\w*)[ ]*[*]?[ ]*(?P<factor2>[-]?\d*)[ ]*)'
)
completer = QCompleter(
self.appdata.project.cobra_py_model.reactions.list_attr("id"),
self)
completer.setCaseSensitivity(Qt.CaseInsensitive)
self.layout = QVBoxLayout()
l = QLabel(
"Define the yield function Y=c*r/d*r by providing c and d as linear expression of form: \n \
id_1 * w_1 + ... id_n * w_n\n \
Where id_x are reaction ids and w_x optional weighting factor\n"
)
self.layout.addWidget(l)
t1 = QLabel("Define c")
self.layout.addWidget(t1)
self.c = CompleterLineEdit(
self.appdata.project.cobra_py_model.reactions.list_attr("id"), "")
self.c.setCompleter(completer)
self.c.setPlaceholderText("")
self.layout.addWidget(self.c)
t2 = QLabel("Define d")
self.layout.addWidget(t2)
self.d = CompleterLineEdit(
self.appdata.project.cobra_py_model.reactions.list_attr("id"), "")
self.d.setPlaceholderText("")
self.d.setCompleter(completer)
self.layout.addWidget(self.d)
l3 = QHBoxLayout()
self.button = QPushButton("Compute")
self.cancel = QPushButton("Close")
l3.addWidget(self.button)
l3.addWidget(self.cancel)
self.layout.addItem(l3)
self.setLayout(self.layout)
# Connecting the signal
self.c.textChangedX.connect(self.validate_dialog)
self.d.textChangedX.connect(self.validate_dialog)
self.cancel.clicked.connect(self.reject)
self.button.clicked.connect(self.compute)
self.validate_dialog()
def _complete_options(self):
"""Find available completion options."""
text = to_text_string(self.currentText())
opts = glob.glob(text + "*")
opts = sorted([opt for opt in opts if osp.isdir(opt)])
completer = QCompleter(opts, self)
if is_dark_interface():
dark_qss = qdarkstyle.load_stylesheet_from_environment()
completer.popup().setStyleSheet(dark_qss)
self.setCompleter(completer)
return opts
class CompleterLineEdit(QLineEdit):
'''# does new completion after COMMA ,'''
def __init__(self, wordlist, *args):
QLineEdit.__init__(self, *args)
self.mycompleter = QCompleter(wordlist)
self.mycompleter.setCaseSensitivity(Qt.CaseInsensitive)
self.mycompleter.setWidget(self)
self.textChanged.connect(self.text_changed)
self.mycompleter.activated.connect(self.complete_text)
def text_changed(self, text):
all_text = text
text = all_text[:self.cursorPosition()]
prefix = text.split(',')[-1].strip()
self.mycompleter.setCompletionPrefix(prefix)
if prefix != '':
self.mycompleter.complete()
def complete_text(self, text):
cursor_pos = self.cursorPosition()
before_text = self.text()[:cursor_pos]
after_text = self.text()[cursor_pos:]
prefix_len = len(before_text.split(',')[-1].strip())
self.setText(before_text[:cursor_pos - prefix_len] + text + after_text)
self.setCursorPosition(cursor_pos - prefix_len + len(text))
textChangedX = Signal(str)
def _complete_options(self):
"""Find available completion options."""
text = to_text_string(self.currentText())
opts = glob.glob(text + "*")
opts = sorted([opt for opt in opts if osp.isdir(opt)])
self.setCompleter(QCompleter(opts, self))
return opts
def __init__(self, parent=None):
super(FileBrowserInputWidget, self).__init__(parent=parent)
# setup model
self.model = QFileSystemModel()
self.model.setRootPath('/home/')
filters = self.model.filter()
self.model.setFilter(filters | QDir.Hidden)
# setup completer
completer = QCompleter(self.model, self)
self.setCompleter(completer)
installCompleterPopup(completer)
self.setCompleter(completer)
completer.setCaseSensitivity(Qt.CaseInsensitive)
self.autoCompleteList = []
def add_desired_region(self):
i = self.desired_list.rowCount()
self.desired_list.insertRow(i)
completer = QCompleter(
self.appdata.project.cobra_py_model.reactions.list_attr("id"), self)
completer.setCaseSensitivity(Qt.CaseInsensitive)
item = QLineEdit("1")
self.desired_list.setCellWidget(i, 0, item)
item2 = QLineEdit("")
item2.setCompleter(completer)
self.desired_list.setCellWidget(i, 1, item2)
combo = QComboBox(self.desired_list)
combo.insertItem(1, "≤")
combo.insertItem(2, "≥")
self.desired_list.setCellWidget(i, 2, combo)
item = QLineEdit("0")
self.desired_list.setCellWidget(i, 3, item)
def __init__(self):
QPlainTextEdit.__init__(self)
self.setWordWrapMode(QTextOption.NoWrap)
self.setFont(QFont("monospace", 10))
self.setCursorWidth(2)
self.installEventFilter(self)
self.completer = QCompleter(self)
self.completer.setWidget(self)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.completer.activated.connect(self.insertCompletion)
auto_complete = QShortcut(QKeySequence("Ctrl+Space"), self)
auto_complete.activated.connect(self.activateCompleter)
copy_line = QShortcut(QKeySequence("Ctrl+D"), self)
copy_line.activated.connect(self.duplicateLine)
select_fragment = QShortcut(QKeySequence("Ctrl+J"), self)
select_fragment.activated.connect(self.selectFragment)
def __init__(self, appdata):
QDialog.__init__(self)
self.setWindowTitle("Phase plane plotting")
self.appdata = appdata
completer = QCompleter(
self.appdata.project.cobra_py_model.reactions.list_attr("id"),
self)
completer.setCaseSensitivity(Qt.CaseInsensitive)
self.layout = QVBoxLayout()
l1 = QHBoxLayout()
t1 = QLabel("Reaction (x-axis):")
l1.addWidget(t1)
self.x_axis = CompleterLineEdit(
self.appdata.project.cobra_py_model.reactions.list_attr("id"), "")
self.x_axis.setPlaceholderText("Enter reaction Id")
l1.addWidget(self.x_axis)
l2 = QHBoxLayout()
t2 = QLabel("Reaction (y-axis):")
l2.addWidget(t2)
self.y_axis = QLineEdit("")
self.y_axis.setPlaceholderText("Enter reaction Id")
self.y_axis.setCompleter(completer)
l2.addWidget(self.y_axis)
self.layout.addItem(l1)
self.layout.addItem(l2)
l3 = QHBoxLayout()
self.button = QPushButton("Plot")
self.cancel = QPushButton("Close")
l3.addWidget(self.button)
l3.addWidget(self.cancel)
self.layout.addItem(l3)
self.setLayout(self.layout)
# Connecting the signal
self.cancel.clicked.connect(self.reject)
self.button.clicked.connect(self.compute)
def initialize(self):
history = STATUS.mdi_history.value
if self._completer_enabled:
completer = QCompleter()
completer.setCaseSensitivity(Qt.CaseInsensitive)
self.model = QStringListModel()
completer.setModel(self.model)
self.setCompleter(completer)
self.model.setStringList(history)
STATUS.mdi_history.notify(self.model.setStringList)
STATUS.max_mdi_history_length = self.mdi_history_size
def __init__(self, parent=None):
super(MDIEntry, self).__init__(parent)
self.model = QStringListModel()
completer = QCompleter()
completer.setCaseSensitivity(Qt.CaseInsensitive)
completer.setModel(self.model)
self.setCompleter(completer)
self.validator = Validator(self)
self.setValidator(self.validator)
self.returnPressed.connect(self.submit)
def __init__(self, parent=None):
super(MDIEntry, self).__init__(parent)
self.mdi_rtnkey_behaviour_supressed = False
self.mdi_history_size = 100
completer = QCompleter()
completer.setCaseSensitivity(Qt.CaseInsensitive)
self.model = QStringListModel()
completer.setModel(self.model)
self.setCompleter(completer)
self.validator = Validator(self)
self.setValidator(self.validator)
self.returnPressed.connect(self.submit)
def __init__(self, parent=None):
super(MDIEntry, self).__init__(parent)
self.model = QStringListModel()
completer = QCompleter()
completer.setCaseSensitivity(Qt.CaseInsensitive)
completer.setModel(self.model)
self.setCompleter(completer)
self.validator = Validator(self)
self.setValidator(self.validator)
self.loadMDIHystory()
self.returnPressed.connect(self.submit)
QApplication.instance().aboutToQuit.connect(self.saveMDIHistory)
def __init__(self, parent=None):
super().__init__(parent)
self._compl = QCompleter(list(get_color_dict()) + ['transparent'])
self._compl.setCompletionMode(QCompleter.InlineCompletion)
self.setCompleter(self._compl)
self.setTextMargins(2, 2, 2, 2)
import sys
from qtpy.QtCore import Qt
from qtpy.QtWidgets import QApplication, QCompleter, QLineEdit, QStringListModel
def get_data(model):
model.setStringList(["completion", "data", "goes", "here"])
if __name__ == "__main__":
app = QApplication(sys.argv)
edit = QLineEdit()
completer = QCompleter()
edit.setCompleter(completer)
model = QStringListModel()
completer.setModel(model)
get_data(model)
edit.show()
sys.exit(app.exec_())
class IdePanel(QPlainTextEdit):
def __init__(self):
QPlainTextEdit.__init__(self)
self.setWordWrapMode(QTextOption.NoWrap)
self.setFont(QFont("monospace", 10))
self.setCursorWidth(2)
self.installEventFilter(self)
self.completer = QCompleter(self)
self.completer.setWidget(self)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.completer.activated.connect(self.insertCompletion)
auto_complete = QShortcut(QKeySequence("Ctrl+Space"), self)
auto_complete.activated.connect(self.activateCompleter)
copy_line = QShortcut(QKeySequence("Ctrl+D"), self)
copy_line.activated.connect(self.duplicateLine)
select_fragment = QShortcut(QKeySequence("Ctrl+J"), self)
select_fragment.activated.connect(self.selectFragment)
def getText(self):
return self.document().toPlainText()
def eventFilter(self, qobject, qevent):
if qobject == self and qevent.type() == QEvent.ToolTip:
text_cursor = self.cursorForPosition(qevent.pos())
pos = text_cursor.positionInBlock()
user_data = text_cursor.block().userData()
if user_data is not None:
#: :type: ConfigurationLine
configuration_line = user_data.configuration_line
# if configuration_line.keyword().hasKeywordDefinition():
# print(configuration_line.keyword().keywordDefinition().documentation)
if pos in configuration_line.keyword():
self.setToolTip(
configuration_line.validationStatusForToken(
configuration_line.keyword()).message())
else:
for argument in configuration_line.arguments():
if pos in argument:
self.setToolTip(
configuration_line.validationStatusForToken(
argument).message())
else:
self.setToolTip("")
return QPlainTextEdit.eventFilter(self, qobject, qevent)
def activateCompleter(self):
text_cursor = self.textCursor()
block = self.document().findBlock(text_cursor.position())
position_in_block = text_cursor.positionInBlock()
self.selectWordUnderCursor(text_cursor)
word = unicode(text_cursor.selectedText())
user_data = block.userData()
self.completer.setCompletionPrefix(word)
show_completer = False
if user_data is None:
self.completer.setModel(QStringListModel(self.handler_names))
show_completer = True
else:
keyword = user_data.keyword
options = keyword.handler.parameterOptions(keyword, word,
position_in_block)
if len(options) == 1:
self.insertCompletion(options[0])
elif len(options) > 1:
self.completer.setModel(QStringListModel(options))
if self.completer.completionCount() == 1:
self.insertCompletion(self.completer.currentCompletion())
else:
show_completer = True
if show_completer:
rect = self.cursorRect(text_cursor)
rect.setWidth(
self.completer.popup().sizeHintForColumn(0) +
self.completer.popup().verticalScrollBar().sizeHint().width())
self.completer.complete(rect)
def keyPressEvent(self, qkeyevent):
if self.completer.popup().isVisible():
dead_keys = [
Qt.Key_Enter,
Qt.Key_Return,
Qt.Key_Escape,
Qt.Key_Tab,
Qt.Key_Backtab,
]
if qkeyevent.key() in dead_keys:
qkeyevent.ignore()
return
if qkeyevent.modifiers() == Qt.ShiftModifier:
if qkeyevent.key() & Qt.Key_Delete == Qt.Key_Delete:
self.deleteLine()
QPlainTextEdit.keyPressEvent(self, qkeyevent)
def insertCompletion(self, string):
text_cursor = self.textCursor()
self.selectWordUnderCursor(text_cursor)
text_cursor.insertText(string)
def isCursorInSpace(self):
text_cursor = self.textCursor()
if text_cursor.positionInBlock() > 0:
text_cursor.movePosition(QTextCursor.Left, QTextCursor.MoveAnchor)
text_cursor.movePosition(QTextCursor.Right, QTextCursor.KeepAnchor)
if text_cursor.positionInBlock() < text_cursor.block().length() - 1:
text_cursor.movePosition(QTextCursor.Right, QTextCursor.KeepAnchor)
if unicode(text_cursor.selectedText()).strip() == "":
return True
return False
def selectWordUnderCursor(self, text_cursor):
if not self.isCursorInSpace():
# text_cursor.select(QTextCursor.WordUnderCursor)
# pattern = "[\s|\v|\f|\n|\r|\t|\xe2\x80\xa8|\xe2\x80\xa9]"
# pattern = "[\\s|\\xe2\\x80\\xa9|\\xe2\\x80\\xa8]"
block_start = 0
block_end = text_cursor.block().length()
cursor_pos = text_cursor.positionInBlock()
pos = cursor_pos
pattern = u"[\\s\u2029\u2028]"
while pos >= block_start:
text_cursor.movePosition(QTextCursor.Left,
QTextCursor.KeepAnchor)
text = text_cursor.selectedText()
if re.search(pattern, text):
break
pos -= 1
text_cursor.movePosition(QTextCursor.Right, QTextCursor.MoveAnchor)
while pos < block_end:
text_cursor.movePosition(QTextCursor.Right,
QTextCursor.KeepAnchor)
text = text_cursor.selectedText()
if re.search(pattern, text):
break
pos += 1
text_cursor.movePosition(QTextCursor.Left, QTextCursor.KeepAnchor)
# pattern = "[\\s]"
# start = self.document().find(QRegExp(pattern), text_cursor, QTextDocument.FindBackward | QTextDocument.FindCaseSensitively)
# end = self.document().find(QRegExp(pattern), text_cursor, QTextDocument.FindCaseSensitively)
# block_end_pos = text_cursor.block().position() + text_cursor.block().length()
#
# text_cursor.setPosition(start.position(), QTextCursor.MoveAnchor)
# # text_cursor.setPosition(min(block_end_pos, end.position() - 1), QTextCursor.KeepAnchor)
# text_cursor.setPosition(end.position() - 1, QTextCursor.KeepAnchor)
def deleteLine(self):
text_cursor = self.textCursor()
text_cursor.beginEditBlock()
text_cursor.select(QTextCursor.LineUnderCursor)
text_cursor.removeSelectedText()
text_cursor.deletePreviousChar()
text_cursor.movePosition(QTextCursor.NextBlock)
text_cursor.movePosition(QTextCursor.StartOfLine)
self.setTextCursor(text_cursor)
text_cursor.endEditBlock()
def duplicateLine(self):
text_cursor = self.textCursor()
text_cursor.beginEditBlock()
text_cursor.select(QTextCursor.LineUnderCursor)
text = text_cursor.selectedText()
text_cursor.movePosition(QTextCursor.EndOfLine)
text_cursor.insertBlock()
text_cursor.insertText(text)
text_cursor.endEditBlock()
def selectFragment(self):
text_cursor = self.textCursor()
self.selectWordUnderCursor(text_cursor)
self.setTextCursor(text_cursor)
def __init__(self, parent):
QComboBox.__init__(self, parent)
self.setEditable(True)
self.setCompleter(QCompleter(self))
self.numpress = 0
self.selected_text = self.currentText()
def hide_completer(self):
"""Hides the completion widget."""
self.setCompleter(QCompleter([], self))
def __init__(self, appdata: CnaData, centralwidget):
QDialog.__init__(self)
self.setWindowTitle("Minimal Cut Sets Computation")
self.appdata = appdata
self.centralwidget = centralwidget
self.eng = appdata.engine
self.out = io.StringIO()
self.err = io.StringIO()
self.layout = QVBoxLayout()
l1 = QLabel("Target Region(s)")
self.layout.addWidget(l1)
s1 = QHBoxLayout()
completer = QCompleter(
self.appdata.project.cobra_py_model.reactions.list_attr("id"), self)
completer.setCaseSensitivity(Qt.CaseInsensitive)
self.target_list = QTableWidget(1, 4)
self.target_list.setHorizontalHeaderLabels(
["region no", "T", "≥/≤", "t"])
self.target_list.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
self.target_list.horizontalHeader().setSectionResizeMode(0, QHeaderView.Fixed)
self.target_list.horizontalHeader().resizeSection(0, 100)
self.target_list.horizontalHeader().setSectionResizeMode(2, QHeaderView.Fixed)
self.target_list.horizontalHeader().resizeSection(2, 50)
item = QLineEdit("1")
self.target_list.setCellWidget(0, 0, item)
item2 = QLineEdit("")
item2.setCompleter(completer)
self.target_list.setCellWidget(0, 1, item2)
combo = QComboBox(self.target_list)
combo.insertItem(1, "≤")
combo.insertItem(2, "≥")
self.target_list.setCellWidget(0, 2, combo)
item = QLineEdit("0")
self.target_list.setCellWidget(0, 3, item)
s1.addWidget(self.target_list)
s11 = QVBoxLayout()
self.add_target = QPushButton("+")
self.add_target.clicked.connect(self.add_target_region)
self.rem_target = QPushButton("-")
self.rem_target.clicked.connect(self.rem_target_region)
s11.addWidget(self.add_target)
s11.addWidget(self.rem_target)
s1.addItem(s11)
self.layout.addItem(s1)
l2 = QLabel("Desired Region(s)")
self.layout.addWidget(l2)
s2 = QHBoxLayout()
self.desired_list = QTableWidget(1, 4)
self.desired_list.setHorizontalHeaderLabels(
["region no", "D", "≥/≤", "d"])
self.desired_list.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
self.desired_list.horizontalHeader().setSectionResizeMode(0, QHeaderView.Fixed)
self.desired_list.horizontalHeader().resizeSection(0, 100)
self.desired_list.horizontalHeader().setSectionResizeMode(2, QHeaderView.Fixed)
self.desired_list.horizontalHeader().resizeSection(2, 50)
item = QLineEdit("1")
self.desired_list.setCellWidget(0, 0, item)
item2 = QLineEdit("")
item2.setCompleter(completer)
self.desired_list.setCellWidget(0, 1, item2)
combo = QComboBox(self.desired_list)
combo.insertItem(1, "≤")
combo.insertItem(2, "≥")
self.desired_list.setCellWidget(0, 2, combo)
item = QLineEdit("0")
self.desired_list.setCellWidget(0, 3, item)
s2.addWidget(self.desired_list)
s21 = QVBoxLayout()
self.add_desire = QPushButton("+")
self.add_desire.clicked.connect(self.add_desired_region)
self.rem_desire = QPushButton("-")
self.rem_desire.clicked.connect(self.rem_desired_region)
s21.addWidget(self.add_desire)
s21.addWidget(self.rem_desire)
s2.addItem(s21)
self.layout.addItem(s2)
s3 = QHBoxLayout()
sgx = QVBoxLayout()
self.gen_kos = QCheckBox("Gene KOs")
self.exclude_boundary = QCheckBox(
"Exclude boundary\nreactions as cuts")
sg1 = QHBoxLayout()
s31 = QVBoxLayout()
l = QLabel("Max. Solutions")
s31.addWidget(l)
l = QLabel("Max. Size")
s31.addWidget(l)
l = QLabel("Time Limit [sec]")
s31.addWidget(l)
sg1.addItem(s31)
s32 = QVBoxLayout()
self.max_solu = QLineEdit("inf")
self.max_solu.setMaximumWidth(50)
s32.addWidget(self.max_solu)
self.max_size = QLineEdit("7")
self.max_size.setMaximumWidth(50)
s32.addWidget(self.max_size)
self.time_limit = QLineEdit("inf")
self.time_limit.setMaximumWidth(50)
s32.addWidget(self.time_limit)
sg1.addItem(s32)
sgx.addWidget(self.gen_kos)
sgx.addWidget(self.exclude_boundary)
sgx.addItem(sg1)
s3.addItem(sgx)
g3 = QGroupBox("Solver")
s33 = QVBoxLayout()
self.bg1 = QButtonGroup()
optlang_solver_name = interface_to_str(
appdata.project.cobra_py_model.problem)
self.solver_optlang = QRadioButton(f"{optlang_solver_name} (optlang)")
self.solver_optlang.setToolTip(
"Uses the solver specified by the current model.")
s33.addWidget(self.solver_optlang)
self.bg1.addButton(self.solver_optlang)
self.solver_cplex_matlab = QRadioButton("CPLEX (MATLAB)")
self.solver_cplex_matlab.setToolTip(
"Only enabled with MATLAB and CPLEX")
s33.addWidget(self.solver_cplex_matlab)
self.bg1.addButton(self.solver_cplex_matlab)
self.solver_cplex_java = QRadioButton("CPLEX (Octave)")
self.solver_cplex_java.setToolTip("Only enabled with Octave and CPLEX")
s33.addWidget(self.solver_cplex_java)
self.bg1.addButton(self.solver_cplex_java)
self.solver_intlinprog = QRadioButton("intlinprog (MATLAB)")
self.solver_intlinprog.setToolTip("Only enabled with MATLAB")
s33.addWidget(self.solver_intlinprog)
self.bg1.addButton(self.solver_intlinprog)
self.solver_glpk = QRadioButton("GLPK (Octave/MATLAB)")
s33.addWidget(self.solver_glpk)
self.bg1.addButton(self.solver_glpk)
self.bg1.buttonClicked.connect(self.configure_solver_options)
g3.setLayout(s33)
s3.addWidget(g3)
g4 = QGroupBox("MCS search")
s34 = QVBoxLayout()
self.bg2 = QButtonGroup()
self.any_mcs = QRadioButton("any MCS (fast)")
self.any_mcs.setChecked(True)
s34.addWidget(self.any_mcs)
self.bg2.addButton(self.any_mcs)
# Search type: by cardinality only with CPLEX possible
self.mcs_by_cardinality = QRadioButton("by cardinality")
s34.addWidget(self.mcs_by_cardinality)
self.bg2.addButton(self.mcs_by_cardinality)
self.smalles_mcs_first = QRadioButton("smallest MCS first")
s34.addWidget(self.smalles_mcs_first)
self.bg2.addButton(self.smalles_mcs_first)
g4.setLayout(s34)
s3.addWidget(g4)
self.layout.addItem(s3)
# Disable incompatible combinations
if appdata.selected_engine == 'None':
self.solver_optlang.setChecked(True)
self.solver_cplex_matlab.setEnabled(False)
self.solver_cplex_java.setEnabled(False)
self.solver_glpk.setEnabled(False)
self.solver_intlinprog.setEnabled(False)
if optlang_solver_name != 'cplex':
self.mcs_by_cardinality.setEnabled(False)
else:
self.solver_glpk.setChecked(True)
if not self.eng.is_cplex_matlab_ready():
self.solver_cplex_matlab.setEnabled(False)
if not self.eng.is_cplex_java_ready():
self.solver_cplex_java.setEnabled(False)
if self.appdata.is_matlab_set():
self.solver_cplex_java.setEnabled(False)
if not self.appdata.is_matlab_set():
self.solver_cplex_matlab.setEnabled(False)
self.solver_intlinprog.setEnabled(False)
self.configure_solver_options()
s4 = QVBoxLayout()
self.consider_scenario = QCheckBox(
"Consider constraint given by scenario")
s4.addWidget(self.consider_scenario)
self.advanced = QCheckBox(
"Advanced: Define knockout/addition costs for genes/reactions")
self.advanced.setEnabled(False)
s4.addWidget(self.advanced)
self.layout.addItem(s4)
buttons = QHBoxLayout()
# self.save = QPushButton("save")
# buttons.addWidget(self.save)
# self.load = QPushButton("load")
# buttons.addWidget(self.load)
self.compute_mcs = QPushButton("Compute MCS")
buttons.addWidget(self.compute_mcs)
# self.compute_mcs2 = QPushButton("Compute MCS2")
# buttons.addWidget(self.compute_mcs2)
self.cancel = QPushButton("Close")
buttons.addWidget(self.cancel)
self.layout.addItem(buttons)
# max width for buttons
self.add_target.setMaximumWidth(20)
self.rem_target.setMaximumWidth(20)
self.add_desire.setMaximumWidth(20)
self.rem_desire.setMaximumWidth(20)
self.setLayout(self.layout)
# Connecting the signal
self.cancel.clicked.connect(self.reject)
self.compute_mcs.clicked.connect(self.compute)