class StringFilterWidget(AbstractFilterWidget):
def __init__(self, field: str, parent=None):
super().__init__(parent)
self.field = field
vlayout = QVBoxLayout()
vlayout.setContentsMargins(0, 0, 0, 0)
self.edit = QLineEdit()
vlayout.addWidget(self.edit)
self.setLayout(vlayout)
self.completer = QCompleter()
self.completer_model = QStringListModel()
self.completer.setModel(self.completer_model)
self.edit.setCompleter(self.completer)
self.edit.textChanged.connect(self.changed)
def setup(self, conn: sqlite3.Connection):
self.completer_model.setStringList(
sql.get_field_unique_values(conn, self.field))
def get_filters(self):
name = self.field
value = self.edit.text()
if not value:
return ""
else:
return {"field": name, "operator": "~", "value": value}
class HelpWidget(QDockWidget):
def __init__(self):
super(HelpWidget, self).__init__()
# TODO: ovo treba da bude kao neki widget u koji moze da se unese instrukcija ili registar ili direktiva
# TODO: pa mu se onda ispise neki uredjeni HTML kao onaj tekst iz praktikuma sta ta kljucna rec znaci
# TODO: mozda da se ispisu i neki odabrani algoritmi npr. sabiranje u dvostrukoj preciznosti sa ilustracijama
# TODO: ili iteriranje kroz niz
self.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea)
self.setMinimumWidth(200)
self.setStyleSheet("background-color: #2D2D30; color: white;")
self.searchLabel = QLineEdit()
self.searchLabel.setPlaceholderText("Search for an instruction...")
self.completer = QCompleter(list(InstructionsInfo.INFO.keys()), self)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.completer.popup().setStyleSheet(
"background-color: #2D2D30; color: white")
self.searchLabel.setCompleter(self.completer)
self.searchLabel.setStyleSheet(
"margin-bottom: 10px; margin-top: 10px;")
self.setTitleBarWidget(self.searchLabel)
self.setFeatures(QDockWidget.DockWidgetMovable
| QDockWidget.DockWidgetClosable)
self.setWindowTitle("Instructions help")
self.resultBox = QTextEdit()
self.resultBox.setReadOnly(True)
self.setWidget(self.resultBox)
def keyPressEvent(self, event):
if event.key() == Qt.Key_Return and self.searchLabel.hasFocus():
seachWord = self.searchLabel.text().strip()
if seachWord in InstructionsInfo.INFO:
self.resultBox.setHtml(InstructionsInfo.INFO[seachWord])
super(HelpWidget, self).keyPressEvent(event)
class Window(QWidget):
def __init__(self):
super().__init__()
self.setWindowTitle(
"Pyside2 COmpleter") # Configure le titre de la fenêtre
self.setGeometry(300, 300, 300,
250) # Configure la taille de la fenêtre
self.setIcon()
self.createCompleter()
def setIcon(self):
appIcon = QIcon("icon.png")
self.setWindowIcon(appIcon)
def createCompleter(self):
vbox = QVBoxLayout()
names = ["Antoine", "Lucie", "Justine", "Dorian", "Lucas", "Fabrice"]
completer = QCompleter(
names
) # Crée un completeur qui quand on écrit propose en fonction des champs données
self.lineEdit = QLineEdit(
) # Créer un input dans lequel on peut écrire
self.lineEdit.setCompleter(completer)
vbox.addWidget(self.lineEdit)
self.setLayout(vbox)
def __init__(self, lookup_names: List[str], on_entered: CallbackType) -> None:
widget = QLineEdit("")
completer = QCompleter(lookup_names)
completer.setCaseSensitivity(Qt.CaseInsensitive)
completer.setFilterMode(Qt.MatchFlag.MatchContains)
completer.setMaxVisibleItems(50)
widget.setCompleter(completer)
super().__init__("Название рецепта:", widget)
self._on_recipe_name_entered = on_entered
self._connect_slots()
def __init__(self):
QMainWindow.__init__(self)
self.setMinimumSize(QSize(480, 80))
self.setWindowTitle("Auto complete")
central_widget = QWidget(self)
self.setCentralWidget(central_widget)
grid_layout = QGridLayout()
central_widget.setLayout(grid_layout)
grid_layout.addWidget(QLabel("Test test", self), 0, 0)
lineEdit = QLineEdit(self)
strList = ['Python', 'PyQt5', 'Qt', 'Django', 'QML']
completer = QCompleter(strList, lineEdit)
lineEdit.setCompleter(completer)
grid_layout.addWidget(lineEdit, 0, 1)
def __init__(self, food_names: List[str],
on_ingredient_entered: CallbackType,
on_ingredient_finalized: CallbackType) -> None:
super().__init__()
self._food_names = food_names
self._on_ingredient_entered = on_ingredient_entered
self._on_ingredient_finalized = on_ingredient_finalized
# ingredient
ingredient_label = QLabel("Продукт:")
ingredient_line_edit = QLineEdit()
# Completer for the ingredient line edit
completer = QCompleter(self._food_names)
completer.setCaseSensitivity(Qt.CaseInsensitive)
ingredient_line_edit.setCompleter(completer)
# ingredient mass line edit
ingredient_mass_line_edit = QLineEdit()
ingredient_mass_line_edit.setPlaceholderText("Масса (гр.)")
ingredient_mass_line_edit.setFixedWidth(100)
ingredient_mass_line_edit.setValidator(QIntValidator())
ingredient_mass_line_edit.setMaxLength(4)
# Button to add ingredient to the recipe
ingredient_add_button = QPushButton("+")
# Layout for ingredient_label / ingredient_line_edit
ingredient_layout = QHBoxLayout()
ingredient_layout.addWidget(ingredient_label)
ingredient_layout.addWidget(ingredient_line_edit)
ingredient_layout.addWidget(ingredient_mass_line_edit)
ingredient_layout.addWidget(ingredient_add_button)
self.setLayout(ingredient_layout)
self._ingredient_line_edit = ingredient_line_edit
self._ingredient_mass_line_edit = ingredient_mass_line_edit
self._ingredient_add_button = ingredient_add_button
self._connect_slots()
class Window(QWidget):
def __init__(self):
super(Window, self).__init__()
self.setWindowTitle("Pyside2 Completer")
self.setGeometry(300, 300, 300, 300)
self.createCompleter()
def createCompleter(self):
vbox = QVBoxLayout()
names = [
"Afghanistan", "Argentina", "India", "Pakistan", "Japan",
"Indonesia", "China", "UAE", "America", "Armanistan", "Azerbaijan",
"Chicago", "Chile"
]
completer = QCompleter(names)
self.lineEdit = QLineEdit()
self.lineEdit.setCompleter(completer)
vbox.addWidget(self.lineEdit)
self.setLayout(vbox)
def __init__(self, lookup_names: List,
on_item_added: CallbackType) -> None:
super().__init__()
recipe_search_label = QLabel("Блюдо:")
recipe_search_line_edit = QLineEdit("")
completer = QCompleter(lookup_names)
completer.setCaseSensitivity(Qt.CaseInsensitive)
completer.setFilterMode(Qt.MatchFlag.MatchContains)
completer.setMaxVisibleItems(50)
recipe_search_line_edit.setCompleter(completer)
serves_amount_label = QLabel("Порций:")
serves_amount_line_edit = QLineEdit(str(self.DEFAULT_SERVES_AMOUNT))
serves_amount_line_edit.setFixedWidth(30)
serves_amount_line_edit.setValidator(QIntValidator())
serves_amount_line_edit.setMaxLength(2)
add_push_button = QPushButton("+")
# Widget layout
layout = QHBoxLayout()
layout.addWidget(recipe_search_label)
layout.addWidget(recipe_search_line_edit)
layout.addWidget(serves_amount_label)
layout.addWidget(serves_amount_line_edit)
layout.addWidget(add_push_button)
layout.addStretch()
self.setLayout(layout)
# Init self data
self._on_item_added = on_item_added
self._recipe_search_line_edit = recipe_search_line_edit
self._serves_amount_line_edit = serves_amount_line_edit
self._add_push_button = add_push_button
# Connect slots
self._connect_slots()
class DownloadDirTreeWidget(QWidget):
def __init__(self, root_path) -> None:
QWidget.__init__(self)
# self.index stores the index of the latest item which is clicked
# self.root_path is the path to the folder currently showing
self.index = None
self.root_path = os.path.abspath(root_path)
self.dir_view = QTreeView()
self.model = QFileSystemModel(self.dir_view)
self.model.setRootPath(self.root_path)
self.dir_view.clicked.connect(self.onFileItemClicked)
self.dir_view.doubleClicked.connect(self.onFileItemDoubleClicked)
self.dir_view.setModel(self.model)
self.dir_view.setRootIndex(self.model.index(self.root_path))
open_button = QPushButton("Open")
open_button.clicked.connect(self.openFile)
open_in_file_explorer_button = QPushButton("Open in File Explorer")
open_in_file_explorer_button.clicked.connect(self.openInFileExplorer)
self.root_path_line_edit = QLineEdit(self.root_path)
self.root_path_line_edit.returnPressed.connect(
self.onChangeLineEditReturned)
self.root_path_line_edit.setSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Minimum)
self.root_path_line_edit.adjustSize()
change_path_button = QPushButton('Change Directory')
change_path_button.clicked.connect(self.onChangeButtonClicked)
addressCompleter = QCompleter()
addressCompleter.setModel(self.model)
self.root_path_line_edit.setCompleter(addressCompleter)
# Set layout
layout = QGridLayout()
layout.addWidget(self.root_path_line_edit, 0, 0, 1, 1)
layout.addWidget(change_path_button, 0, 1, 1, 1)
layout.addWidget(self.dir_view, 1, 0, 1, 2)
layout.addWidget(open_button, 2, 0, 1, 1)
layout.addWidget(open_in_file_explorer_button, 2, 1, 1, 1)
layout.setMargin(0)
self.setLayout(layout)
def setRootPath(self, root_path):
self.root_path = os.path.abspath(root_path)
def openFile(self):
if self.index is not None:
file_path = self.model.filePath(self.index).replace('/', '\\')
is_dir = self.model.isDir(self.index)
# If is file, open with default program
# If is directory, open with file explorer
if is_dir is False:
os.startfile(file_path, 'open')
else:
subprocess.run(['explorer', file_path])
def openInFileExplorer(self):
if self.index is None:
file_path = self.model.filePath(self.index).replace('/', '\\')
subprocess.run(['explorer', '/select,', file_path])
def onFileItemClicked(self, index):
# When clicked, resize and update self.index
self.dir_view.resizeColumnToContents(0)
self.index = index
def onFileItemDoubleClicked(self, index):
# When double clicked, update self.index and open the file directly
self.index = index
if self.sender().model().isDir(index) is False:
self.openFile()
def onChangeButtonClicked(self):
new_path = QFileDialog.getExistingDirectory(self, 'Change Directory',
self.root_path)
self.changeRootPath(new_path)
def onChangeLineEditReturned(self):
new_path = self.root_path_line_edit.text()
if os.path.isdir(new_path):
self.changeRootPath(new_path)
else:
subprocess.run(['explorer', new_path])
self.root_path_line_edit.setText(self.root_path)
def changeRootPath(self, new_path: str):
if os.path.exists(new_path):
self.root_path = os.path.abspath(new_path)
self.dir_view.setRootIndex(self.model.index(self.root_path))
self.root_path_line_edit.setText(self.root_path)
class AdomanyFormDialog(QDialog):
""" A fogadott paraméter (table) alapján állítjuk össze a form-ot.
Lekérdezzük a tábla struktúrát és összerakjuk a mezőnevek listáját,
kihagyva a Primary mező-nevet. Ezek lesznek a LABEl-ek. A mező értékeket
szintén egy LIST-ben tárojuk a későbbi feldolgozás lehetővé tétele érdekében"""
def __init__(self):
super(AdomanyFormDialog, self).__init__()
self.mezo_nevek = []
self.mezo_ertekek = []
self.layout = QFormLayout()
self.setLayout(self.layout)
reg_datum = QRegExp('(19[0-9]{2}\\-([0][1-9]|[1][0-2])\\-([0][1-9]|[1-2][0-9]|3[0-1]))|(20[0-9]{2}\\-([0][1-9]|[1][0-2])\\-([0][1-9]|[1-2][0-9]|3[0-1]))')
datumvalidator = QRegExpValidator(reg_datum)
self.jogcim_completer = QCompleter()
self.get_jogcimdata()
fizmod_completer = QCompleter()
self.fizmod_model = QStringListModel()
fizmod_completer.setModel(self.fizmod_model)
self.get_fizmoddata()
self.mezo_nevek.append("Dátum")
self.mezo_nevek.append("Nyugta száma")
self.mezo_nevek.append("Befizető")
self.mezo_nevek.append("Jogcím")
self.mezo_nevek.append("Összeg")
self.mezo_nevek.append("Fizetési mód")
self.mezo_nevek.append("Megjegyzés")
for i in range(len(self.mezo_nevek)):
if (self.mezo_nevek[i] == "Dátum"):
datum = QLineEdit()
datum.setText(QDate.currentDate().toString("yyyy-MM-dd"))
datum.setValidator(datumvalidator)
self.mezo_ertekek.append(datum)
if (self.mezo_nevek[i] == "Nyugta száma"):
nyugta = QLineEdit()
nyugta.setText("0")
self.mezo_ertekek.append(nyugta)
if (self.mezo_nevek[i] == "Befizető"):
self.befizeto = QLineEdit()
self.befizeto.setText("Vendég")
self.mezo_ertekek.append(self.befizeto)
if (self.mezo_nevek[i] == "Jogcím"):
self.jogcim = QLineEdit()
self.jogcim.setCompleter(self.jogcim_completer)
self.mezo_ertekek.append(self.jogcim)
if (self.mezo_nevek[i] == "Összeg"):
self.osszeg = QLineEdit()
self.mezo_ertekek.append(self.osszeg)
if (self.mezo_nevek[i] == "Fizetési mód"):
self.fizmod = QLineEdit()
self.fizmod.setCompleter(fizmod_completer)
self.fizmod.setText("Készpénz")
self.mezo_ertekek.append(self.fizmod)
if (self.mezo_nevek[i] == "Megjegyzés"):
megjegyzes = QLineEdit()
self.mezo_ertekek.append(megjegyzes)
self.layout.addRow(f"{self.mezo_nevek[i]}", self.mezo_ertekek[i])
buttonbox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
buttonbox.accepted.connect(self.accept)
buttonbox.rejected.connect(self.reject)
self.layout.addWidget(buttonbox)
def get_jogcimdata(self):
jogcimek_model = QSqlQueryModel()
query = QSqlQuery("SELECT jogcim FROM jogcim order by jogcim", db=db)
jogcimek_model.setQuery(query)
self.jogcim_completer.setModel(jogcimek_model)
def get_fizmoddata(self):
self.fizmod_model.setStringList(["Készpénz", "Átutalás"])
class TraceWindow(QMainWindow):
def __init__(self, qmp):
QMainWindow.__init__(self)
self.qmp = qmp
os.system('rm /tmp/errors.log 2>/dev/null')
self.trace_events = self.qmp.hmp_command('info trace-events')
self.qmp.hmp_command('logfile /tmp/errors.log')
self.trace_events = sorted(
self.trace_events['return'].split('\r\n'))[1:]
self.activated = []
self.length = 100
self.timer = QTimer(self)
self.timer.timeout.connect(self.disp_output)
self.timer.start(100)
self.init_ui()
def init_ui(self):
self.setWindowTitle('Trace Event Window')
self.setGeometry(100, 100, 800, 600)
bar = self.menuBar()
file_ = bar.addMenu('File')
export_log = QAction('Save to File',
self,
triggered=lambda: self.save_log())
options = bar.addMenu('Options')
auto_refresh = QAction(
'Auto Refresh',
self,
checkable=True,
triggered=lambda: self.timer.start(100)
if auto_refresh.isChecked() else self.timer.stop())
auto_refresh.setChecked(True)
options.addAction(auto_refresh)
file_.addAction(export_log)
vgrid = QVBoxLayout()
grid = QHBoxLayout()
self.tree = QTreeWidget()
self.tree.setHeaderLabels(['Name'])
self.top = []
self.lst = []
for n, event in enumerate(self.trace_events):
word = event.split('_')[0]
if word not in self.top:
self.top.append(word)
item = QTreeWidgetItem(self.tree)
self.lst.append(item)
item.setText(0, word)
subitem = QTreeWidgetItem(item)
subitem.setText(0, ' ' + event.split(' : ')[0])
# subitem.setCheckState(0, Qt.Unchecked)
cbox = QCheckBox()
cbox.stateChanged.connect(lambda state, text=subitem.text(0): self.
handle_checked(state, text))
self.tree.setItemWidget(subitem, 0, cbox)
# self.tree.setColumnWidth(0, 25)
self.tracelist = QLabel()
self.disp_output()
self.traceview = QScrollArea()
self.traceview.setWidget(self.tracelist)
self.traceview.setWidgetResizable(True)
search = QHBoxLayout()
self.search_bar = QLineEdit(self)
self.completer = QCompleter(self.top, self)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.search_bar.setCompleter(self.completer)
search_button = QPushButton('Search')
search_button.clicked.connect(lambda: self.tree.setCurrentItem(
self.lst[self.top.index(self.search_bar.text())]))
expand = QPushButton('▼')
expand.setFixedSize(QSize(25, 25))
expand.clicked.connect(lambda: self.tree.expandAll())
collapse = QPushButton('▲')
collapse.setFixedSize(QSize(25, 25))
collapse.clicked.connect(lambda: self.tree.collapseAll())
self.search_bar.returnPressed.connect(lambda: search_button.click())
search.addWidget(self.search_bar)
search.addWidget(search_button)
search.addWidget(expand)
search.addWidget(collapse)
self.digest = QLabel()
vgrid.addLayout(search)
vgrid.addWidget(self.tree)
vgridwid = QWidget()
vgridwid.setLayout(vgrid)
split = QSplitter(Qt.Horizontal)
split.addWidget(vgridwid)
split.addWidget(self.traceview)
split.setStretchFactor(1, 1)
# grid.addLayout(vgrid)
grid.addWidget(split)
# grid.addWidget(self.tracelist)
self.disp_output()
center = QWidget()
center.setLayout(grid)
self.setCentralWidget(center)
self.show()
def disp_output(self):
self.shorten_file()
with open('/tmp/errors.log', 'r') as errors:
self.digest = []
lines = 0
for line in errors:
if re.match(r"\d+@\d+\.\d+:.*", line):
self.digest.append(line)
lines += 1
if not self.digest:
self.digest = ['<font color="grey">Empty...</font>']
self.digest = ''.join(self.digest[-self.length:])
self.tracelist.setText(self.digest)
self.tracelist.setFont(QFont('Monospace', 10))
self.tracelist.setTextInteractionFlags(Qt.TextSelectableByMouse)
def shorten_file(self):
with open('/tmp/errors.log', 'r+') as tracefile:
content = ''.join(tracefile.readlines()[-(self.length * 3):])
tracefile.seek(0)
tracefile.truncate()
tracefile.write(content)
def save_log(self):
name = QFileDialog.getSaveFileName(self, 'Save File', '',
'Text files (*.txt)')
log_file = open(name[0], 'w')
log_file.write(self.digest)
log_file.close()
def handle_checked(self, state, text):
if state:
self.qmp.hmp_command('trace-event %s on' % text.strip())
self.activated.append(text)
else:
self.qmp.hmp_command('trace-event %s off' % text.strip())
self.activated.remove(text)
def closeEvent(self, event):
self.timer.stop()
for e in self.activated:
self.qmp.hmp_command('trace-event %s off' % e.strip())
os.system('rm /tmp/errors.log')
event.accept()
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 GameSettingsDialog(QDialog):
def __init__(self, parent=None):
super(GameSettingsDialog, self).__init__(parent)
self.parent = parent
self.setModal(True)
self.setWindowTitle("Game settings")
self.create_widgets()
self.set_layouts()
def create_widgets(self):
self.label_player1 = QLabel("Player 1")
self.input_player1_name = QLineEdit()
self.input_player1_name.setPlaceholderText("Player 1")
self.input_player1_name.setFocus()
self.player1_completer = QCompleter()
self.input_player1_name.setCompleter(self.player1_completer)
self.label_player2 = QLabel("Player 2")
self.input_player2_name = QLineEdit()
self.input_player2_name.setPlaceholderText("Player 2")
self.player2_completer = QCompleter()
self.input_player2_name.setCompleter(self.player2_completer)
# player widget-ek feltültése a db-ben szereplő nevekkel, autocomplete-hez
self.get_player_name()
self.gomb_301 = QRadioButton("301")
self.gomb_401 = QRadioButton("401")
self.gomb_501 = QRadioButton("501")
self.gomb_501.setChecked(True)
self.gomb_701 = QRadioButton("701")
self.label_bestof = QLabel("Best Of.. (Egyébként First To..)")
self.best_of = QCheckBox()
self.spin_legs = QSpinBox()
self.spin_legs.setValue(3)
self.spin_legs.setMinimum(1)
self.spin_legs.setMaximum(21)
self.spin_sets = QSpinBox()
self.spin_sets.setValue(1)
self.spin_sets.setMinimum(1)
self.spin_sets.setMaximum(15)
self.handi1 = QSpinBox()
self.handi1.setValue(0)
self.handi1.setMinimum(-100)
self.handi1.setMaximum(100)
self.handi2 = QSpinBox()
self.handi2.setValue(0)
self.handi2.setMinimum(-100)
self.handi2.setMaximum(100)
self.buttonbox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel
| QDialogButtonBox.Reset)
self.buttonbox.clicked.connect(self.buttonbox_click)
def set_layouts(self):
self.layout = QVBoxLayout()
self.setLayout(self.layout)
self.kontener_names = QHBoxLayout()
self.kontener_names.addWidget(self.label_player1)
self.kontener_names.addWidget(self.input_player1_name)
self.kontener_names.addWidget(self.label_player2)
self.kontener_names.addWidget(self.input_player2_name)
self.kontener_buttons = QHBoxLayout()
self.kontener_buttons.addWidget(self.gomb_301)
self.kontener_buttons.addWidget(self.gomb_401)
self.kontener_buttons.addWidget(self.gomb_501)
self.kontener_buttons.addWidget(self.gomb_701)
self.bestof_layout = QHBoxLayout()
self.bestof_layout.addWidget(self.label_bestof)
self.bestof_layout.addWidget(self.best_of)
self.kontener_szovegek1 = QVBoxLayout()
self.kontener_szovegek1.addWidget(
QLabel("Leave Player 2 blank for single player"))
self.kontener_szovegek1.addWidget(QLabel("Variant"))
self.kontener_sets = QHBoxLayout()
self.kontener_sets.addWidget(QLabel("Legs per set: "))
self.kontener_sets.addWidget(self.spin_legs)
self.kontener_sets.addWidget(QLabel("Number os sets: "))
self.kontener_sets.addWidget(self.spin_sets)
self.kontener_handi = QHBoxLayout()
self.kontener_handi.addWidget(QLabel("Handicap (1)"))
self.kontener_handi.addWidget(self.handi1)
self.kontener_handi.addWidget(QLabel("Handicap (2)"))
self.kontener_handi.addWidget(self.handi2)
self.layout.addLayout(self.kontener_names)
self.layout.addLayout(self.kontener_szovegek1)
self.layout.addLayout(self.kontener_buttons)
self.layout.addLayout(self.bestof_layout)
self.layout.addLayout(self.kontener_sets)
self.layout.addLayout(self.kontener_handi)
self.layout.addWidget(self.buttonbox)
def get_player_name(self):
player_name_model = QSqlQueryModel()
query = QSqlQuery(
"SELECT player_name FROM players where type='local' and aktiv=1 order by player_name",
db=db)
player_name_model.setQuery(query)
self.player1_completer.setModel(player_name_model)
self.player2_completer.setModel(player_name_model)
def buttonbox_click(self, b):
if b.text() == "OK":
self.accept()
elif b.text() == "Cancel":
self.reject()
else:
self.alapertekek()
def alapertekek(self):
self.input_player1_name.setText("")
self.input_player1_name.setPlaceholderText("Player 1 name")
self.input_player2_name.setText("")
self.input_player2_name.setPlaceholderText("Player 2 name")
self.gomb_501.setChecked(True)
self.best_of.setChecked(False)
self.spin_legs.setValue(3)
self.spin_sets.setValue(1)
self.handi1.setValue(0)
self.handi2.setValue(0)
def accept(self):
params = []
m_id = p1_id = p2_id = set = leg = hc1 = hc2 = 0
var = ""
player1 = self.input_player1_name.text()
player2 = self.input_player2_name.text()
# todo A MATCH_ID-T VALAMI EGYEDI MÓDON KELL GENERÁLNI(pl. az időbélyeg bizonyos részével)
m_id = random.randint(10, 1000000)
leg = self.spin_legs.value()
set = self.spin_sets.value()
hc1 = self.handi1.value()
hc2 = self.handi2.value()
if self.gomb_301.isChecked():
var = "301"
elif self.gomb_401.isChecked():
var = "401"
elif self.gomb_501.isChecked():
var = "501"
else:
var = "701"
if self.best_of.isChecked():
bestof = 1
else:
bestof = 0
if len(player1) == 0:
p1_id = 1
player1 = "Player 1"
else:
player1_id_model = QSqlQueryModel()
query1 = QSqlQuery(
f"SELECT player_id FROM players where player_name = '{player1}' and type='local' and aktiv=1",
db=db)
player1_id_model.setQuery(query1)
# todo megnézni, hogy sima query.exec_ -el hogyan működik, lehet-e ellenőrizni, hogy üres vagy nem
if player1_id_model.record(0).value(0):
p1_id = int(player1_id_model.record(0).value(0))
else:
# todo beszúrás előtt ellenőritni, hogy egyedi-e. Létezhet versenyen felvitt ugyanolyan név
player_model1 = QSqlTableModel()
player_model1.setTable("players")
rec_play1 = player_model1.record()
rec_play1.remove(0)
rec_play1.setValue(0, player1)
rec_play1.setValue(1, 'local')
rec_play1.setValue(2, 1)
if player_model1.insertRecord(-1, rec_play1):
player_model1.submitAll()
else:
db.rollback()
query1 = QSqlQuery(
f"SELECT player_id FROM players where player_name = '{player1}' and type='local' and aktiv=1",
db=db)
player1_id_model.setQuery(query1)
# todo megnézni, hogy sima query.exec_ -el hogyan működik, lehet-e ellenőrizni, hogy üres vagy nem
p1_id = int(player1_id_model.record(0).value(0))
if len(player2) == 0:
p2_id = 2
player2 = "Player 2"
else:
player2_id_model = QSqlQueryModel()
query2 = QSqlQuery(
f"SELECT player_id FROM players where player_name = '{player2}' and type='local' and aktiv=1",
db=db)
player2_id_model.setQuery(query2)
# todo megnézni, hogy sima query.exec_ -el hogyan működik, lehet-e ellenőrizni, hogy üres vagy nem
if player2_id_model.record(0).value(0):
p2_id = int(player2_id_model.record(0).value(0))
else:
player_model2 = QSqlTableModel()
player_model2.setTable("players")
rec_play2 = player_model2.record()
rec_play2.remove(0)
rec_play2.setValue(0, player2)
rec_play2.setValue(1, 'local')
rec_play2.setValue(2, 1)
if player_model2.insertRecord(-1, rec_play2):
player_model2.submitAll()
else:
db.rollback()
query2 = QSqlQuery(
f"SELECT player_id FROM players where player_name = '{player2}' and type='local' and aktiv=1",
db=db)
player2_id_model.setQuery(query2)
# todo megnézni, hogy sima query.exec_ -el hogyan működik, lehet-e ellenőrizni, hogy üres vagy nem
p2_id = int(player2_id_model.record(0).value(0))
# Match paremeterek rögzítése
now = QDateTime.currentDateTime()
match_model = QSqlTableModel()
match_model.setTable("match_settings")
# todo Best Of... nincs db-ben tárolva
record = match_model.record()
record.setValue(0, m_id)
record.setValue(1, p1_id)
record.setValue(2, p2_id)
record.setValue(3, var)
record.setValue(4, leg)
record.setValue(5, set)
record.setValue(6, hc1)
record.setValue(7, hc2)
record.setValue(8, now)
if match_model.insertRecord(-1, record):
match_model.submitAll()
else:
db.rollback()
params.append(player1)
params.append(player2)
params.append(m_id)
params.append(p1_id)
params.append(p2_id)
params.append(var)
params.append(leg)
params.append(set)
params.append(hc1)
params.append(hc2)
params.append(bestof)
self.parent.new_game_window.params = params
self.parent.new_game_window.refresh()
super().accept()
def reject(self):
self.parent.new_game_window.close()
super().reject()
class SearchBar(QWidget):
def __init__(self):
super(SearchBar, self).__init__()
self.layout = QVBoxLayout()
self.layout.setMargin(0)
self.setStyleSheet(
css('border: 1px solid {{color}};', color=colors.SECONDARY_COLOR))
self.searchbar = QLineEdit()
self.searchbar.setPlaceholderText(
'Try searching for an artist or album')
self.searchbar.textChanged.connect(self.set_keywords)
self.searchbar.returnPressed.connect(self.search)
self.searchbar.setStyleSheet(
css('''
QLineEdit {
padding: 10px;
border-radius: 8px;
background: {{backgroundColor}};
}
''',
backgroundColor=colors.PLACEHOLDER_COLOR))
self.layout.addWidget(self.searchbar)
self.setLayout(self.layout)
def set_keywords(self, keywords):
self.keywords = keywords
def search(self):
if self.searchbar.completer() and self.searchbar.completer().popup(
).isVisible():
# User did select an option from the dropdown menu.
selected_suggestion = [
s for s in self.suggestions if s['label'] == self.keywords
]
if len(selected_suggestion) > 0:
self.searchbar.setCompleter(None)
PageSignal.changed.emit(
SongDetailPage(url=selected_suggestion[0]['url']))
else:
# User did type something and then hit ENTER to search.
self.thread = RunThread(self.get_search_suggestions,
self.on_search_suggestions)
def get_search_suggestions(self):
if self.keywords:
self.searchbar.setEnabled(False)
logging.info(
'Getting search suggestions for keywords: "{}"'.format(
self.keywords))
spider = CoreRadioSpider()
self.suggestions = spider.get_search_suggestions(self.keywords)
def on_search_suggestions(self):
logging.info('Received search suggestions for keywords: "{}"'.format(
self.keywords))
self.searchbar.setEnabled(True)
self.searchbar.setFocus()
if self.suggestions:
suggestions = [
suggestion['label'] for suggestion in self.suggestions
]
completer = QCompleter(suggestions)
completer.setCaseSensitivity(Qt.CaseInsensitive)
self.searchbar.setCompleter(completer)
self.searchbar.completer().complete()
self.searchbar.completer().popup().setStyleSheet(
css(
"""
QListView {
border: 1px solid {{borderColor}};
padding: 10px;
background: {{backgroundColor}};
}
QItemSelection {
padding: 10px;
}
""",
borderColor=colors.SECONDARY_COLOR,
backgroundColor=colors.PLACEHOLDER_COLOR,
))
class QTagWidget(QWidget):
def __init__(self, parent, items):
super(QTagWidget, self).__init__()
self.parent = parent
self.items = items
self.tags = []
self.mainFrame = QFrame()
self.mainFrame.setStyleSheet(
'border:1px solid #76797C; border-radius: 1px;')
self.mainLayout = QVBoxLayout()
self.mainLayout.setContentsMargins(0, 0, 0, 0)
self.setLayout(self.mainLayout)
self.mainLayout.addWidget(self.mainFrame)
self.hLayout = QHBoxLayout()
self.hLayout.setSpacing(4)
self.lineEdit = QLineEdit()
self.lineEdit.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Maximum)
completer = QPartialMatchCompleter(self.lineEdit)
completer.setCompletionMode(QCompleter.PopupCompletion)
self.lineEdit.setCompleter(completer)
model = QStringListModel()
completer.setModel(model)
model.setStringList(self.items)
self.mainFrame.setLayout(self.hLayout)
self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
self.hLayout.setContentsMargins(2, 2, 2, 2)
self.refresh()
self.setup_ui()
def show(self):
self.show()
def setup_ui(self):
self.lineEdit.returnPressed.connect(self.create_tags)
def create_tags(self):
new_tags = self.lineEdit.text().split(', ')
self.lineEdit.setText('')
self.tags.extend(new_tags)
self.tags = list(set(self.tags))
self.tags.sort(key=lambda x: x.lower())
self.refresh()
def refresh(self):
for i in reversed(range(self.hLayout.count())):
self.hLayout.itemAt(i).widget().setParent(None)
for tag in self.tags:
self.add_tag_to_bar(tag)
self.hLayout.addWidget(self.lineEdit)
self.lineEdit.setFocus()
# Accept to add only 5 tags
if len(self.tags) >= 5:
self.lineEdit.setDisabled(True)
return
def add_tag_to_bar(self, text):
tag = QFrame()
tag.setStyleSheet(
'border:1px solid rgb(192, 192, 192); border-radius: 4px;')
tag.setContentsMargins(2, 2, 2, 2)
tag.setFixedHeight(28)
hbox = QHBoxLayout()
hbox.setContentsMargins(4, 4, 4, 4)
hbox.setSpacing(10)
tag.setLayout(hbox)
label = QLabel(text)
label.setStyleSheet('border:0px')
label.setFixedHeight(16)
hbox.addWidget(label)
x_button = QPushButton('x')
x_button.setFixedSize(20, 20)
x_button.setStyleSheet('border:0px; font-weight:bold')
x_button.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
x_button.clicked.connect(partial(self.delete_tag, text))
hbox.addWidget(x_button)
tag.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Preferred)
self.hLayout.addWidget(tag)
def delete_tag(self, tag_name):
self.tags.remove(tag_name)
# Make input available if tags count is less than 5
if len(self.tags) < 5:
self.lineEdit.setDisabled(False)
self.refresh()
class ConsoleDialog(QDialog):
def __init__(self, node):
super().__init__()
self.node = node
self.show_help = True
self.layout = QGridLayout()
self.setLayout(self.layout)
self.output_area = QTextEdit()
self.output_area.setReadOnly(True)
self.output_area.acceptRichText = True
self.output_area.document().setMaximumBlockCount(5000)
self.layout.addWidget(self.output_area)
self.input_area = QLineEdit()
self.completer = QCompleter()
# noinspection PyUnresolvedReferences
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.input_area.setCompleter(self.completer)
self.input_area.setFocus()
self.layout.addWidget(self.input_area)
self.connect(self.input_area, SIGNAL("returnPressed(void)"),
self.execute_user_command)
@property
def cli(self):
try:
return self.node.software.cli
except AttributeError:
return None
@property
def cli_args(self):
try:
return self.node.configuration.cli_args
except AttributeError:
return None
def showEvent(self, event):
super().showEvent(event)
if self.show_help:
success = self.run_command('help')
if success:
self.show_help = False
def execute_user_command(self):
cmd = str(self.input_area.text())
self.input_area.clear()
self.run_command(cmd)
def run_command(self, command):
try:
if self.cli is None or self.cli_args is None:
self.output_area.append(
'Node starting up, please try again later...')
return False
self.output_area.append(f'> {command}\n')
process = QProcess()
process.setProgram(self.cli)
process.setCurrentReadChannel(0)
# noinspection PyUnresolvedReferences
process.readyReadStandardError.connect(
lambda: self.handle_cli_error_output(process))
# noinspection PyUnresolvedReferences
process.readyReadStandardOutput.connect(
lambda: self.handle_cli_output(process))
args = command.split(' ')
if args[0] == self.cli.split('/')[-1]:
args.pop(0)
process.setArguments(self.cli_args + args)
process.start()
log.info('run_command',
program=self.cli,
args=self.cli_args,
cmd=command)
return True
except Exception:
self.output_area.append(
'Node starting up, please try again later...')
return False
def handle_cli_error_output(self, cli_process: QProcess):
output: QByteArray = cli_process.readAllStandardError()
message = output.data().decode('utf-8').strip()
self.output_area.append(message)
def handle_cli_output(self, cli_process: QProcess):
output: QByteArray = cli_process.readAllStandardOutput()
message = output.data().decode('utf-8').strip()
if message.startswith('{') or message.startswith('['):
formatter = HtmlFormatter()
formatter.noclasses = True
formatter.linenos = False
formatter.nobackground = True
message = highlight(message, JsonLexer(), formatter)
self.output_area.insertHtml(message)
else:
self.output_area.append(message)
class ConsoleDialog(QDialog):
def __init__(self, title: str,
program: str,
args: List[str],
commands: List[str]):
super().__init__()
self.setWindowTitle(title)
self.program = program
self.args = args
self.layout = QGridLayout()
self.output = QTextEdit()
self.output.acceptRichText = True
self.input = QLineEdit()
self.completer = QCompleter(commands, self)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.input.setCompleter(self.completer)
self.input.setFocus()
self.layout.addWidget(self.output)
self.layout.addWidget(self.input)
self.setLayout(self.layout)
self.connect(self.input, SIGNAL("returnPressed(void)"),
self.execute_user_command)
self.connect(self.completer, SIGNAL("activated(const QString&)"),
self.input.clear, Qt.QueuedConnection)
def execute_user_command(self):
cmd = str(self.input.text())
self.run_command(cmd)
def run_command(self, cmd: str):
log.info(
'run_command',
program=self.program,
args=self.args,
cmd=cmd
)
self.output.append(f'> {cmd}\n')
self.input.clear()
process = QProcess()
process.setProgram(self.program)
process.setCurrentReadChannel(0)
# noinspection PyUnresolvedReferences
process.readyReadStandardError.connect(
lambda: self.handle_error(process)
)
# noinspection PyUnresolvedReferences
process.readyReadStandardOutput.connect(
lambda: self.handle_output(process)
)
connect_args = list(self.args)
args = cmd.split(' ')
if args[0] == self.program.split('/')[-1]:
args.pop(0)
process.setArguments(connect_args + args)
process.start()
def handle_error(self, process: QProcess):
output: QByteArray = process.readAllStandardError()
message = output.data().decode('utf-8').strip()
self.output.append(message)
def handle_output(self, process: QProcess):
output: QByteArray = process.readAllStandardOutput()
message = output.data().decode('utf-8').strip()
if message.startswith('{') or message.startswith('['):
formatter = HtmlFormatter()
formatter.noclasses = True
formatter.linenos = False
formatter.nobackground = True
message = highlight(message, JsonLexer(), formatter)
self.output.insertHtml(message)
else:
self.output.append(message)
# This is just for generating the command lists in constants
# commands = None
# if '== Blockchain ==' in message:
# commands = self.parse_litecoin_cli_commands(message)
# elif 'lncli [global options] command [command options]' in message:
# commands = self.parse_lncli_commands(message)
# if commands is not None:
# log.debug('commands', commands=commands)
max_scroll = self.output.verticalScrollBar().maximum()
self.output.verticalScrollBar().setValue(max_scroll)
@staticmethod
def parse_litecoin_cli_commands(message: str):
log.debug('parse_litecoin_cli_commands')
commands = []
for line in message.split(sep='\n'):
line = line.strip()
if not line or line.startswith('=='):
continue
command = line.split()[0]
command = command.strip()
commands.append(command)
return commands
@staticmethod
def parse_lncli_commands(message: str):
log.debug('parse_lncli_commands')
at_commands = False
commands = []
for line in message.split(sep='\n'):
line = line.strip()
if not at_commands:
if 'COMMANDS:' in line:
at_commands = True
log.debug('commands line',
line=line)
continue
elif 'GLOBAL OPTIONS' in line:
return commands
elif line.endswith(':') or not line:
continue
command = line.split()[0]
command = command.strip().replace(',', '')
commands.append(command)
return commands
def show(self):
self.showMaximized()
self.raise_()
self.setWindowState(self.windowState() & ~Qt.WindowMinimized | Qt.WindowActive)
self.activateWindow()
self.input.setFocus()
self.run_command('help')
class KiadasFormDialog(QDialog):
def __init__(self):
super(KiadasFormDialog, self).__init__()
self.mezo_nevek = []
self.mezo_ertekek = []
self.layout = QFormLayout()
self.setLayout(self.layout)
reg_datum = QRegExp(
'(19[0-9]{2}\\-([0][1-9]|[1][0-2])\\-([0][1-9]|[1-2][0-9]|3[0-1]))|(20[0-9]{2}\\-([0][1-9]|[1][0-2])\\-([0][1-9]|[1-2][0-9]|3[0-1]))'
)
datumvalidator = QRegExpValidator(reg_datum)
self.kedvezmenyezett_completer = QCompleter()
self.get_kedvezmenyezettdata()
fizmod_completer = QCompleter()
self.fizmod_model = QStringListModel()
fizmod_completer.setModel(self.fizmod_model)
self.get_fizmoddata()
self.mezo_nevek.append("Dátum")
self.mezo_nevek.append("Bizonylat száma")
self.mezo_nevek.append("Kedvezményezett")
self.mezo_nevek.append("Jogcím")
self.mezo_nevek.append("Összeg")
self.mezo_nevek.append("Fizetési mód")
self.mezo_nevek.append("Megjegyzés")
for i in range(len(self.mezo_nevek)):
if (self.mezo_nevek[i] == "Dátum"):
datum = QLineEdit()
datum.setText(QDate.currentDate().toString("yyyy-MM-dd"))
datum.setValidator(datumvalidator)
self.mezo_ertekek.append(datum)
if (self.mezo_nevek[i] == "Bizonylat száma"):
nyugta = QLineEdit()
nyugta.setText("0")
self.mezo_ertekek.append(nyugta)
if (self.mezo_nevek[i] == "Kedvezményezett"):
self.kedvezmenyezett = QLineEdit()
self.kedvezmenyezett.setCompleter(
self.kedvezmenyezett_completer)
# Ide kellene egy QCompleter
# self.befizeto.setText("Vendég")
self.mezo_ertekek.append(self.kedvezmenyezett)
if (self.mezo_nevek[i] == "Jogcím"):
self.jogcim = QLineEdit()
# self.jogcim.setCompleter(self.jogcim_completer)
self.mezo_ertekek.append(self.jogcim)
if (self.mezo_nevek[i] == "Összeg"):
self.osszeg = QLineEdit()
self.mezo_ertekek.append(self.osszeg)
if (self.mezo_nevek[i] == "Fizetési mód"):
self.fizmod = QLineEdit()
self.fizmod.setCompleter(fizmod_completer)
self.fizmod.setText("Készpénz")
self.mezo_ertekek.append(self.fizmod)
if (self.mezo_nevek[i] == "Megjegyzés"):
megjegyzes = QLineEdit()
self.mezo_ertekek.append(megjegyzes)
self.layout.addRow(f"{self.mezo_nevek[i]}", self.mezo_ertekek[i])
buttonbox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
buttonbox.accepted.connect(self.accept)
buttonbox.rejected.connect(self.reject)
self.layout.addWidget(buttonbox)
def get_kedvezmenyezettdata(self):
kedvezm_model = QSqlQueryModel()
query = QSqlQuery(
"SELECT megnevezes FROM kedvezmenyezettek order by megnevezes",
db=db)
kedvezm_model.setQuery(query)
self.kedvezmenyezett_completer.setModel(kedvezm_model)
def get_fizmoddata(self):
self.fizmod_model.setStringList(["Készpénz", "Átutalás"])
class GameSettingsDialog(QDialog):
def __init__(self):
super(GameSettingsDialog, self).__init__()
self.setModal(True)
self.setWindowTitle("Game settings")
self.layout = QVBoxLayout()
self.setLayout(self.layout)
self.kontener_names = QHBoxLayout()
self.kontener_buttons = QHBoxLayout()
self.kontener_szovegek1 = QVBoxLayout()
self.kontener_sets = QHBoxLayout()
self.layout.addLayout(self.kontener_names)
self.layout.addLayout(self.kontener_szovegek1)
self.layout.addLayout(self.kontener_buttons)
self.layout.addLayout(self.kontener_sets)
self.label_player1 = QLabel("Player 1")
self.input_player1_name = QLineEdit()
self.input_player1_name.setPlaceholderText("Player 1 name")
self.input_player1_name.setFocus()
self.player1_completer = QCompleter()
self.input_player1_name.setCompleter(self.player1_completer)
self.label_player2 = QLabel("Player 2")
self.input_player2_name = QLineEdit()
self.input_player2_name.setPlaceholderText("Player 2 name")
self.player2_completer = QCompleter()
self.input_player2_name.setCompleter(self.player2_completer)
self.get_player_name()
self.kontener_names.addWidget(self.label_player1)
self.kontener_names.addWidget(self.input_player1_name)
self.kontener_names.addWidget(self.label_player2)
self.kontener_names.addWidget(self.input_player2_name)
self.kontener_szovegek1.addWidget(
QLabel("Leave Player 2 blank for single player"))
self.kontener_szovegek1.addWidget(QLabel("Variant"))
self.gomb_301 = QRadioButton("301")
self.gomb_301.toggled.connect(lambda: self.btnstate(self.gomb_301))
self.gomb_401 = QRadioButton("401")
self.gomb_401.toggled.connect(lambda: self.btnstate(self.gomb_401))
self.gomb_501 = QRadioButton("501")
self.gomb_501.toggled.connect(lambda: self.btnstate(self.gomb_501))
self.gomb_501.setChecked(True)
self.gomb_701 = QRadioButton("701")
self.gomb_701.toggled.connect(lambda: self.btnstate(self.gomb_701))
self.kontener_buttons.addWidget(self.gomb_301)
self.kontener_buttons.addWidget(self.gomb_401)
self.kontener_buttons.addWidget(self.gomb_501)
self.kontener_buttons.addWidget(self.gomb_701)
self.spin_legs = QSpinBox()
self.spin_legs.setValue(3)
self.spin_legs.setMinimum(1)
self.spin_legs.setMaximum(21)
self.spin_sets = QSpinBox()
self.spin_sets.setValue(1)
self.spin_sets.setMinimum(1)
self.spin_sets.setMaximum(15)
self.kontener_sets.addWidget(QLabel("Legs per set: "))
self.kontener_sets.addWidget(self.spin_legs)
self.kontener_sets.addWidget(QLabel("Number os sets: "))
self.kontener_sets.addWidget(self.spin_sets)
self.buttonbox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel
| QDialogButtonBox.Reset)
# buttonbox.accepted.connect(self.accept)
# buttonbox.rejected.connect(self.reject)
self.buttonbox.clicked.connect(self.buttonbox_click)
self.layout.addWidget(self.buttonbox)
def get_player_name(self):
player_name_model = QSqlQueryModel()
query = QSqlQuery(
"SELECT player_name FROM players order by player_name", db=db)
player_name_model.setQuery(query)
self.player1_completer.setModel(player_name_model)
self.player2_completer.setModel(player_name_model)
def buttonbox_click(self, b):
if b.text() == "OK":
self.accept()
elif b.text() == "Cancel":
self.reject()
else:
self.alapertekek()
# def accept(self):
# # print("OK-ra kattintott")
# super().accept()
# def reject(self):
# print(self.parent)
# # self.parent.bezar()
# QApplication.
# super().reject()
# parent.close()
def alapertekek(self):
self.input_player1_name.setText("")
self.input_player1_name.setPlaceholderText("Player 1")
self.input_player2_name.setText("")
self.input_player2_name.setPlaceholderText("Player 2")
self.gomb_501.setChecked(True)
self.spin_legs.setValue(3)
self.spin_sets.setValue(1)
def btnstate(self, b):
if b.text() == "301":
if b.isChecked() == True:
print(b.text() + " is selected")
else:
print(b.text() + " is deselected")
if b.text() == "501":
if b.isChecked() == True:
print(b.text() + " is selected")
else:
print(b.text() + " is deselected")
