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 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 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 GlobalState(object):
"""Stores all global state not handled by Qt."""
# TODO: Refactor settings into here
def __init__(self):
self._tag_completer = QCompleter()
# Sort by descending file count
tagnames = [
tag[0] for tag in sorted(get_all_tags(), key=lambda t: -t[1])
]
self._tag_completer.setModel(QStringListModel(tagnames))
@property
def tag_completer(self) -> QCompleter:
"""A dropdown completer used for any tag entry widget."""
return self._tag_completer
class FSLineEdit(QLineEdit):
"""
A line edit with auto completion for file system folders.
"""
def __init__(self, parent=None):
QLineEdit.__init__(self, parent)
self.fsmodel = QFileSystemModel()
self.fsmodel.setRootPath("")
self.completer = QCompleter()
self.completer.setModel(self.fsmodel)
self.setCompleter(self.completer)
self.fsmodel.setFilter(QDir.Drives | QDir.AllDirs | QDir.Hidden |
QDir.NoDotAndDotDot)
def setPath(self, path):
self.setText(path)
self.fsmodel.setRootPath(path)
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 _create_completer(self):
"""Create Completer with his model
Fill the model with the SQL keywords and database fields
"""
model = QStringListModel()
completer = QCompleter()
keywords = []
samples = [i["name"] for i in sql.get_samples(self.conn)]
selections = [i["name"] for i in sql.get_selections(self.conn)]
for field in sql.get_fields(self.conn):
if field["category"] == "samples":
for sample in samples:
keywords.append("sample['{}'].{}".format(sample, field["name"]))
else:
keywords.append(field["name"])
keywords.extend(VqlSyntaxHighlighter.sql_keywords)
keywords.extend(selections)
model.setStringList(keywords)
completer.setModel(model)
return completer
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)
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 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 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")
class QuickAssetLoaderUI(QtWidgets.QDialog):
def __init__(self, ui_path=None, parent=maya_main_window()):
super(QuickAssetLoaderUI, self).__init__(parent)
self.setWindowTitle("Quick Asset Loader")
self.setFixedSize(600, 523)
# Remove the weird question Mark on the dialog window
self.setWindowFlags(self.windowFlags()
^ QtCore.Qt.WindowContextHelpButtonHint)
self.assets_db = db.AssetDB("{0}/resource/dbAssets.txt".format(
os.path.dirname(__file__)))
self.init_ui(ui_path)
self.create_layout()
self.create_connections()
self.completer = None
self.asset_to_path = None
def init_ui(self, ui_path=None):
if not ui_path:
ui_path = "{0}/resource/qDesignerUI.ui".format(
os.path.dirname(__file__))
# IF A DB OF ASSETS DOES NOT EXIST CREATE IT
if not os.path.isfile("{0}/resource/dbAssets.txt".format(
os.path.dirname(__file__))):
self.assets_db.update_asset_db()
# SETTING UP THE QCOMPLETER FOR FASTER INTERACTIONS
db_file = open(
"{0}/resource/dbAssets.txt".format(os.path.dirname(__file__)), "r")
assets = db_file.readlines()
# Cleaning the line stripping out the end line character
for i in range(len(assets)):
assets[i] = assets[i].rstrip('\n')
self.asset_to_path = asset_entity.AssetEntity()
self.completer = QCompleter()
model = QtGui.QStringListModel()
self.completer.setModel(model)
model.setStringList(assets)
f = QtCore.QFile(ui_path)
f.open(QtCore.QFile.ReadOnly)
loader = QtUiTools.QUiLoader()
self.ui = loader.load(f, parentWidget=self)
f.close()
def create_layout(self):
self.ui.layout().setContentsMargins(6, 6, 6, 6)
def create_connections(self):
self.ui.inputText.textChanged.connect(self.populate_suggestions)
self.ui.charmainButton.clicked.connect(self.charmain_button_clicked)
# Setting up the QCompleter to work with inputField
self.ui.inputText.setCompleter(self.completer)
# Connecting Buttons
self.ui.charsecButton.clicked.connect(self.charsec_button_clicked)
self.ui.vehButton.clicked.connect(self.veh_button_clicked)
self.ui.envintButton.clicked.connect(self.envint_button_clicked)
self.ui.envextButton.clicked.connect(self.envext_button_clicked)
self.ui.propButton.clicked.connect(self.prop_button_clicked)
self.ui.reference_button.clicked.connect(self.reference_button)
self.ui.import_button.clicked.connect(self.import_button)
self.ui.tableWidget.itemDoubleClicked.connect(self.cell_double_clicked)
self.ui.updateDBButton.clicked.connect(self.update_db)
def update_db(self):
self.assets_db.update_asset_db()
# TODO define a config file to have presets for most used characters to load
# def char1ButtonClicked(self):
# self.asset_to_path.char1Button()
#
# def char2ButtonClicked(self):
# self.asset_to_path.char2Button()
#
# def char3ButtonClicked(self):
# self.asset_to_path.char3Button()
#
# def char4ButtonClicked(self):
# self.asset_to_path.char4Button()
def cell_double_clicked(self, item):
"""
If an user double clicked on the asset name, it will automatically trying to import it into the scene
:param item: the Item clicked in the UI
"""
if item.text().endswith(".ma"):
if os.path.isfile(self.asset_to_path.get_asset_path()):
self.asset_to_path.import_asset(
self.asset_to_path.get_asset_path())
def charmain_button_clicked(self):
self.ui.inputText.clear()
self.ui.inputText.insert("charmain_")
def charsec_button_clicked(self):
self.ui.inputText.clear()
self.ui.inputText.insert("charsec_")
def veh_button_clicked(self):
self.ui.inputText.clear()
self.ui.inputText.insert("veh_")
def envint_button_clicked(self):
self.ui.inputText.clear()
self.ui.inputText.insert("envint_")
def envext_button_clicked(self):
self.ui.inputText.clear()
self.ui.inputText.insert("envext_")
def prop_button_clicked(self):
self.ui.inputText.clear()
self.ui.inputText.insert("prop_")
# Reference The Asset
def reference_button(self):
asset_name = self.ui.inputText.text()
self.asset_to_path.setTheAsset(asset_name)
self.asset_to_path.referenceIt()
# Import The Asset in Maya
def import_button(self):
asset_name = self.ui.inputText.text()
self.asset_to_path.setTheAsset(asset_name)
self.asset_to_path.openIt()
def populate_suggestions(self, text):
# For Design purpose we want to input always lowercase
self.ui.inputText.setText(text.lower())
# Clean the table everytime something is typed in the inputField
self.ui.tableWidget.setRowCount(0)
try:
full_path = self.asset_to_path.get_asset_path(text.lower())
if full_path is not None:
path, asset_file_name = os.path.split(full_path[0])
self.ui.labelAsset.setText(str(asset_file_name))
if self.asset_to_path.setTheAsset(text) is not None:
asset_files = self.asset_to_path.get_files_in_asset_dir()
self.ui.tableWidget.setRowCount(len(asset_files))
for i in range(0, len(asset_files)):
full_path[0] = asset_files[i]
path, asset_file_name = os.path.split(full_path[0])
file_name_item = QTableWidgetItem(asset_file_name)
file_name_item.setFlags(QtCore.Qt.ItemIsEnabled)
self.ui.tableWidget.setItem(i, 0, file_name_item)
mod_time = datetime.fromtimestamp(
os.path.getmtime(asset_files[i]))
mod_time_item = QTableWidgetItem(str(mod_time))
mod_time_item.setFlags(QtCore.Qt.ItemIsEnabled)
self.ui.tableWidget.setItem(i, 1, mod_time_item)
self.ui.tableWidget.resizeColumnsToContents()
except AttributeError as e:
# If there is not a matching auto-completion do not throw an exception
return
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 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 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)
