def __init__(self, parent=None):
super().__init__(parent)
options = {
#"pen_pos_down": ("Pen position down:", (0, 100), 40),
#"pen_pos_up": ("Pen position up:", (0, 100), 60),
"pen_rate_lower": ("Pen rate lower:", (1, 100), 50),
"pen_rate_raise": ("Pen rate raise:", (1, 100), 75),
"pen_delay_down": ("Pen delay down:", (-500, 500), 0),
"pen_delay_up": ("Pen delay up:", (-500, 500), 0),
"speed_pendown": ("Speed (pen down):", (1, 110), 25),
"speed_penup": ("Speed (pen up):", (1, 110), 75),
"accel": ("Acceleration:", (1, 100), 75),
}
settings = QSettings()
layout = QFormLayout()
for key, (label, (min_val, max_val), default) in options.items():
spin_box = AxySettingsSpinBox(settings, key, default)
spin_box.setRange(min_val, max_val)
spin_box.setSingleStep(1)
layout.addRow(label, spin_box)
model = QComboBox()
model.addItem("Axidraw V2 or V3", 1)
model.addItem("Axidraw V3/A3 or SE/A3", 2)
model.addItem("Axidraw V3 XLX", 3)
model.addItem("Axidraw MiniKit", 4)
model.currentIndexChanged.connect(
lambda index: axy.set_option("model", model.itemData(index))
)
model.setCurrentIndex(settings.value("model", 0))
model.currentIndexChanged.connect(lambda index: settings.setValue("model", index))
layout.addRow("Model:", model)
btn_box = QDialogButtonBox()
btn_box.setStandardButtons(QDialogButtonBox.Ok)
btn_box.accepted.connect(self.accept)
btn_box.rejected.connect(self.reject)
layout.addRow(btn_box)
self.setLayout(layout)
class ConfigWindow(QDialog):
# noinspection SpellCheckingInspection
LOCALES = {
'en': 'English',
'nl': 'Nederlands'
}
def __init__(self, gui_window: mainWindow.MainWindow, device_manager: logic.DeviceManager):
QDialog.__init__(self, gui_window)
self.setModal(True)
self.setWindowTitle(QCoreApplication.translate('configs', 'Configs', 'title'))
self._device_manager = device_manager
layout = QGridLayout()
layout.addWidget(QLabel(QCoreApplication.translate('configs', 'Open on startup'), self), 0, 0)
self._open_on_startup = QCheckBox(self)
self._open_on_startup.setChecked(device_manager.open_on_start)
self._open_on_startup.stateChanged.connect(self._open_on_startup_changed)
layout.addWidget(self._open_on_startup, 0, 1)
layout.addWidget(QLabel(QCoreApplication.translate('configs', 'Locale'), self), 1, 0)
self._locale_select = QComboBox(self)
self._locale_select.setToolTip(QCoreApplication.translate('configs', 'Restart required'))
for locale_key, locale_value in ConfigWindow.LOCALES.items():
self._locale_select.addItem(locale_value, userData=locale_key)
self._locale_select.setCurrentIndex(self._locale_select.findData(device_manager.locale))
self._locale_select.currentIndexChanged.connect(self._locale_changed)
layout.addWidget(self._locale_select, 1, 1)
self.setLayout(layout)
def _open_on_startup_changed(self, state):
self._device_manager.open_on_start = state == Qt.Checked
def _locale_changed(self, index):
self._device_manager.locale = self._locale_select.itemData(index)
def closeEvent(self, event):
event.ignore()
self.hide()
class QGraphicsSceneOnQVariantTest(UsesQApplication):
"""Test storage ot QGraphicsScene into QVariants"""
def setUp(self):
super(QGraphicsSceneOnQVariantTest, self).setUp()
self.s = MyDiagram()
self.i = MyItem()
self.combo = QComboBox()
def tearDown(self):
del self.s
del self.i
del self.combo
super(QGraphicsSceneOnQVariantTest, self).tearDown()
def testIt(self):
self.s.addItem(self.i)
self.assertEqual(len(self.s.items()), 1)
def testSequence(self):
# PYSIDE-641
self.combo.addItem("test", userData=Sequence())
self.assertTrue(isinstance(self.combo.itemData(0), Sequence))
def on_player_changed(self, player: QComboBox, new_index: int):
if new_index < 0:
# Combo box was cleared.
return
settings = get_settings(self.start_state)
if player is self.ui.player1:
searches = self.ui.searches1
searches_label = self.ui.searches_label1
searches_lock = self.ui.searches_lock1
setting_name = 'player_1'
row = 1
else:
searches = self.ui.searches2
searches_label = self.ui.searches_label2
searches_lock = self.ui.searches_lock2
setting_name = 'player_2'
row = 2
settings.setValue(setting_name, new_index)
heuristic = player.itemData(new_index)
searches.setVisible(heuristic is not None)
searches_label.setVisible(heuristic is not None)
searches_lock.setVisible(heuristic is not None)
colspan = 4 if heuristic is None else 1
self.ui.player_layout.addWidget(player, row, 1, 1, colspan)
class QBuyGroupForGroundObjectDialog(QDialog):
def __init__(
self,
parent,
ground_object: TheaterGroundObject,
cp: ControlPoint,
game: Game,
current_group_value: int,
):
super(QBuyGroupForGroundObjectDialog, self).__init__(parent)
self.setMinimumWidth(350)
self.ground_object = ground_object
self.cp = cp
self.game = game
self.current_group_value = current_group_value
self.setWindowTitle("Buy units @ " + self.ground_object.obj_name)
self.setWindowIcon(EVENT_ICONS["capture"])
self.buySamButton = QPushButton("Buy")
self.buyArmorButton = QPushButton("Buy")
self.buySamLayout = QGridLayout()
self.buyArmorLayout = QGridLayout()
self.amount = QSpinBox()
self.buyArmorCombo = QComboBox()
self.samCombo = QComboBox()
self.buySamBox = QGroupBox("Buy SAM site :")
self.buyArmorBox = QGroupBox("Buy defensive position :")
faction = self.game.player_faction
# Sams
possible_sams = get_faction_possible_sams_generator(faction)
for sam in possible_sams:
# Pre Generate SAM to get the real price
generator = sam(self.game, self.ground_object)
generator.generate()
self.samCombo.addItem(
generator.name + " [$" + str(generator.price) + "M]", userData=generator
)
self.samCombo.currentIndexChanged.connect(self.samComboChanged)
self.buySamLayout.addWidget(QLabel("Site Type :"), 0, 0, Qt.AlignLeft)
self.buySamLayout.addWidget(self.samCombo, 0, 1, alignment=Qt.AlignRight)
self.buySamLayout.addWidget(self.buySamButton, 1, 1, alignment=Qt.AlignRight)
stretch = QVBoxLayout()
stretch.addStretch()
self.buySamLayout.addLayout(stretch, 2, 0)
self.buySamButton.clicked.connect(self.buySam)
# EWRs
buy_ewr_box = QGroupBox("Buy EWR:")
buy_ewr_layout = QGridLayout()
buy_ewr_box.setLayout(buy_ewr_layout)
buy_ewr_layout.addWidget(QLabel("Radar type:"), 0, 0, Qt.AlignLeft)
self.ewr_selector = QComboBox()
buy_ewr_layout.addWidget(self.ewr_selector, 0, 1, alignment=Qt.AlignRight)
ewr_types = get_faction_possible_ewrs_generator(faction)
for ewr_type in ewr_types:
# Pre Generate to get the real price
generator = ewr_type(self.game, self.ground_object)
generator.generate()
self.ewr_selector.addItem(
generator.name() + " [$" + str(generator.price) + "M]",
userData=generator,
)
self.ewr_selector.currentIndexChanged.connect(self.on_ewr_selection_changed)
self.buy_ewr_button = QPushButton("Buy")
self.buy_ewr_button.clicked.connect(self.buy_ewr)
buy_ewr_layout.addWidget(self.buy_ewr_button, 1, 1, alignment=Qt.AlignRight)
stretch = QVBoxLayout()
stretch.addStretch()
buy_ewr_layout.addLayout(stretch, 2, 0)
# Armored units
for unit in set(faction.ground_units):
self.buyArmorCombo.addItem(f"{unit} [${unit.price}M]", userData=unit)
self.buyArmorCombo.currentIndexChanged.connect(self.armorComboChanged)
self.amount.setMinimum(2)
self.amount.setMaximum(8)
self.amount.setValue(2)
self.amount.valueChanged.connect(self.amountComboChanged)
self.buyArmorLayout.addWidget(QLabel("Unit type :"), 0, 0, Qt.AlignLeft)
self.buyArmorLayout.addWidget(self.buyArmorCombo, 0, 1, alignment=Qt.AlignRight)
self.buyArmorLayout.addWidget(
QLabel("Group size :"), 1, 0, alignment=Qt.AlignLeft
)
self.buyArmorLayout.addWidget(self.amount, 1, 1, alignment=Qt.AlignRight)
self.buyArmorLayout.addWidget(
self.buyArmorButton, 2, 1, alignment=Qt.AlignRight
)
stretch2 = QVBoxLayout()
stretch2.addStretch()
self.buyArmorLayout.addLayout(stretch2, 3, 0)
self.buyArmorButton.clicked.connect(self.buyArmor)
# Do layout
self.buySamBox.setLayout(self.buySamLayout)
self.buyArmorBox.setLayout(self.buyArmorLayout)
self.mainLayout = QHBoxLayout()
if isinstance(self.ground_object, SamGroundObject):
self.mainLayout.addWidget(self.buySamBox)
elif isinstance(self.ground_object, VehicleGroupGroundObject):
self.mainLayout.addWidget(self.buyArmorBox)
elif isinstance(self.ground_object, EwrGroundObject):
self.mainLayout.addWidget(buy_ewr_box)
self.setLayout(self.mainLayout)
try:
self.samComboChanged(0)
self.armorComboChanged(0)
self.on_ewr_selection_changed(0)
except:
pass
def samComboChanged(self, index):
self.buySamButton.setText(
"Buy [$"
+ str(self.samCombo.itemData(index).price)
+ "M] [-$"
+ str(self.current_group_value)
+ "M]"
)
def on_ewr_selection_changed(self, index):
ewr = self.ewr_selector.itemData(index)
self.buy_ewr_button.setText(
f"Buy [${ewr.price}M][-${self.current_group_value}M]"
)
def armorComboChanged(self, index):
unit_type = self.buyArmorCombo.itemData(self.buyArmorCombo.currentIndex())
price = unit_type.price * self.amount.value()
self.buyArmorButton.setText(f"Buy [${price}M][-${self.current_group_value}M]")
def amountComboChanged(self):
unit_type = self.buyArmorCombo.itemData(self.buyArmorCombo.currentIndex())
price = unit_type.price * self.amount.value()
self.buyArmorButton.setText(f"Buy [${price}M][-${self.current_group_value}M]")
def buyArmor(self):
logging.info("Buying Armor ")
utype = self.buyArmorCombo.itemData(self.buyArmorCombo.currentIndex())
price = utype.price * self.amount.value() - self.current_group_value
if price > self.game.budget:
self.error_money()
self.close()
return
else:
self.game.budget -= price
# Generate Armor
group = generate_armor_group_of_type_and_size(
self.game, self.ground_object, utype, int(self.amount.value())
)
self.ground_object.groups = [group]
# Replan redfor missions
self.game.initialize_turn(for_red=True, for_blue=False)
GameUpdateSignal.get_instance().updateGame(self.game)
def buySam(self):
sam_generator = self.samCombo.itemData(self.samCombo.currentIndex())
price = sam_generator.price - self.current_group_value
if price > self.game.budget:
self.error_money()
return
else:
self.game.budget -= price
self.ground_object.groups = list(sam_generator.groups)
# Replan redfor missions
self.game.initialize_turn(for_red=True, for_blue=False)
GameUpdateSignal.get_instance().updateGame(self.game)
def buy_ewr(self):
ewr_generator = self.ewr_selector.itemData(self.ewr_selector.currentIndex())
price = ewr_generator.price - self.current_group_value
if price > self.game.budget:
self.error_money()
return
else:
self.game.budget -= price
self.ground_object.groups = [ewr_generator.vg]
# Replan redfor missions
self.game.initialize_turn(for_red=True, for_blue=False)
GameUpdateSignal.get_instance().updateGame(self.game)
def error_money(self):
msg = QMessageBox()
msg.setIcon(QMessageBox.Information)
msg.setText("Not enough money to buy these units !")
msg.setWindowTitle("Not enough money")
msg.setStandardButtons(QMessageBox.Ok)
msg.setWindowFlags(Qt.WindowStaysOnTopHint)
msg.exec_()
self.close()
class QBriefingWindow(QDialog):
def __init__(self, gameEvent: Event):
super(QBriefingWindow, self).__init__()
self.gameEvent = gameEvent
self.setWindowTitle("Briefing : " + str(gameEvent))
self.setMinimumSize(200,200)
self.setWindowIcon(CONST.EVENT_ICONS[self.gameEvent.__class__])
self.setModal(True)
self.game = self.gameEvent.game
if self.gameEvent.attacker_name == self.game.player_name:
self.base = self.gameEvent.from_cp.base
self.playerFromCp = self.gameEvent.from_cp
else:
self.base = self.gameEvent.to_cp.base
self.playerFromCp = self.gameEvent.to_cp
self.scramble_entries = {k: {} for k in self.gameEvent.tasks}
self.initUi()
def initUi(self):
self.layout = QVBoxLayout()
self.depart_box = QGroupBox("Departure")
self.depart_layout = QHBoxLayout()
self.depart_box.setLayout(self.depart_layout)
self.depart_from_label = QLabel("Depart from : ")
self.depart_from = QComboBox()
for i, cp in enumerate([b for b in self.game.theater.controlpoints if b.captured]):
self.depart_from.addItem(str(cp.name), cp)
if cp.name == self.playerFromCp.name:
self.depart_from.setCurrentIndex(i)
self.depart_from.currentTextChanged.connect(self.on_departure_cp_changed)
self.depart_layout.addWidget(self.depart_from_label)
self.depart_layout.addWidget(self.depart_from)
# Mission Description
self.gridLayout = QGridLayout()
self.initUnitRows()
self.scramble_box = QGroupBox("Units")
self.scramble_box.setLayout(self.gridLayout)
self.action_layout = QHBoxLayout()
self.commit_button = QPushButton("Commit")
self.back_button = QPushButton("Cancel")
self.commit_button.clicked.connect(self.start)
self.back_button.clicked.connect(self.close)
self.action_layout.addWidget(self.commit_button)
self.action_layout.addWidget(self.back_button)
self.support_box = self.initSupportBox()
self.layout.addWidget(QLabel("<h2>{} on {}</h2>".format(self.gameEvent, self.gameEvent.to_cp.name)))
self.layout.addWidget(self.depart_box)
self.layout.addWidget(self.scramble_box)
self.layout.addWidget(self.support_box)
self.layout.addWidget(QLabel("<b>Ready?</b>"))
self.layout.addLayout(self.action_layout)
self.setLayout(self.layout)
def initUnitRows(self):
row = 0
def header(text, row):
self.gridLayout.addWidget(QLabel("<b>" + text + "</b>"), row, 0, 1, 2)
def scramble_row(task_type, unit_type, unit_count, client_slots: bool, row: int):
unit_name = QLabel("{} ({})".format(db.unit_type_name(unit_type), unit_count))
self.gridLayout.addWidget(unit_name, row, 0)
scramble_entry = QSpinBox()
self.gridLayout.addWidget(scramble_entry, row, 1)
if client_slots:
client_entry = QSpinBox()
self.gridLayout.addWidget(client_entry, row, 2)
else:
client_entry = None
self.scramble_entries[task_type][unit_type] = scramble_entry, client_entry
# Table headers
self.gridLayout.addWidget(QLabel("Amount"), row, 1)
self.gridLayout.addWidget(QLabel("Client slots"), row, 2)
row += 1
for flight_task in self.gameEvent.tasks:
header("{}:".format(self.gameEvent.flight_name(flight_task)), row)
row += 1
if flight_task == PinpointStrike:
if not self.base.armor:
self.gridLayout.addWidget(QLabel("No units"), row, 1)
row += 1
for t, c in self.base.armor.items():
scramble_row(flight_task, t, c, False, row)
row += 1
else:
if not self.base.aircraft:
self.gridLayout.addWidget(QLabel("No units"), row, 1)
row += 1
for t, c in self.base.aircraft.items():
scramble_row(flight_task, t, c, t.flyable, row)
row += 1
return self.gridLayout
def initSupportBox(self):
self.support_box = QGroupBox("Support")
self.support_layout = QGridLayout()
self.support_box.setLayout(self.support_layout)
self.awacs_label = QLabel("AWACS ({}m)".format(AWACS_BUDGET_COST))
self.awacs_checkbox = QCheckBox()
self.ca_slot_label = QLabel("Combined Arms Slots")
self.ca_slot_entry = QSpinBox()
self.ca_slot_entry.setValue(0)
self.ca_slot_entry.setMinimum(0)
self.ca_slot_entry.setMaximum(32)
self.support_layout.addWidget(self.awacs_label, 0, 0)
self.support_layout.addWidget(self.awacs_checkbox, 0, 1)
self.support_layout.addWidget(self.ca_slot_label, 1, 0)
self.support_layout.addWidget(self.ca_slot_entry, 1, 1)
return self.support_box
def initWaitingForResults(self):
layout = QVBoxLayout()
layout.addWidget(QLabel("<b>You are clear for takeoff</b>"))
layout.addWidget(QLabel("In DCS open and play the mission : "))
layout.addWidget(QLabel("<i>liberation_nextturn</i>"))
layout.addWidget(QLabel("or"))
layout.addWidget(QLabel("<i>liberation_nextturn_quick</i>"))
layout.addWidget(QLabel("<b>Then save the debriefing to folder :</b>"))
layout.addWidget(QLabel("Then save the debriefing to the folder:"))
layout.addWidget(QLabel("<i>" + self.debriefing_directory_location() + "</i>"))
layout.addWidget(QLabel("Waiting for results..."))
# layout.addWidget(QLabel("In DCS open and play the mission : "))
# layout.addWidget(QLabel("<b>You are clear for takeoff</b>"))
self.setLayout(layout)
pass
def debriefing_directory_location(self) -> str:
return os.path.join(base_path(), "liberation_debriefings")
def start(self):
if self.awacs_checkbox.isChecked() == 1:
self.gameEvent.is_awacs_enabled = True
self.game.awacs_expense_commit()
else:
self.gameEvent.is_awacs_enabled = False
ca_slot_entry_value = self.ca_slot_entry.value()
try:
ca_slots = int(ca_slot_entry_value and ca_slot_entry_value or "0")
except:
ca_slots = 0
self.gameEvent.ca_slots = ca_slots
# Resolve Departure CP
self.gameEvent.departure_cp = self.depart_from.itemData(self.depart_from.currentIndex())
flights = {k: {} for k in self.gameEvent.tasks} # type: db.TaskForceDict
units_scramble_counts = {} # type: typing.Dict[typing.Type[UnitType], int]
tasks_scramble_counts = {} # type: typing.Dict[typing.Type[Task], int]
tasks_clients_counts = {} # type: typing.Dict[typing.Type[Task], int]
def dampen_count(unit_type, count: int) -> int:
nonlocal units_scramble_counts
total_count = self.base.total_units_of_type(unit_type)
total_scrambled = units_scramble_counts.get(unit_type, 0)
dampened_value = count if count + total_scrambled < total_count else total_count - total_scrambled
units_scramble_counts[unit_type] = units_scramble_counts.get(unit_type, 0) + dampened_value
return dampened_value
for task_type, dict in self.scramble_entries.items():
for unit_type, (count_entry, clients_entry) in dict.items():
try:
count = int(count_entry.value())
except:
count = 0
try:
clients_count = int(clients_entry and clients_entry.value() or 0)
except:
clients_count = 0
dampened_count = dampen_count(unit_type, count)
tasks_clients_counts[task_type] = tasks_clients_counts.get(task_type, 0) + clients_count
tasks_scramble_counts[task_type] = tasks_scramble_counts.get(task_type, 0) + dampened_count
flights[task_type][unit_type] = dampened_count, clients_count
for task in self.gameEvent.ai_banned_tasks:
if tasks_clients_counts.get(task, 0) == 0 and tasks_scramble_counts.get(task, 0) > 0:
self.showErrorMessage("Need at least one player in flight {}".format(self.gameEvent.flight_name(task)))
return
for task in self.gameEvent.player_banned_tasks:
if tasks_clients_counts.get(task, 0) != 0:
self.showErrorMessage("Players are not allowed on flight {}".format(self.gameEvent.flight_name(task)))
return
if self.game.is_player_attack(self.gameEvent):
if isinstance(self.gameEvent, FrontlineAttackEvent):
if self.base.total_armor == 0:
self.showErrorMessage("No ground vehicles available to attack!")
return
self.gameEvent.player_attacking(flights)
else:
if isinstance(self.gameEvent, FrontlineAttackEvent):
if self.gameEvent.to_cp.base.total_armor == 0:
self.showErrorMessage("No ground vehicles available to defend!")
return
self.gameEvent.player_defending(flights)
self.game.initiate_event(self.gameEvent)
waiting = QWaitingForMissionResultWindow(self.gameEvent, self.game)
waiting.show()
self.close()
def showErrorMessage(self, text):
about = QMessageBox()
about.setWindowTitle("Error")
about.setIcon(QMessageBox.Icon.Critical)
about.setText(text)
about.exec_()
def on_departure_cp_changed(self):
selectedBase = self.depart_from.itemData(self.depart_from.currentIndex())
for i, cp in enumerate([b for b in self.game.theater.controlpoints if b.captured]):
if cp.name == selectedBase.name:
self.base = cp.base
self.playerFromCp = cp
break
# Clear current selection
self.scramble_entries = {k: {} for k in self.gameEvent.tasks}
# Clear the grid layout
for i in reversed(range(self.gridLayout.count())):
self.gridLayout.itemAt(i).widget().setParent(None)
# Rebuild the grid layout, so that it correspond to the newly selected CP
self.initUnitRows()
class rawForm(baseForm):
"""
Postprocessing of raw files.
"""
dataChanged = QtCore.Signal(int)
@classmethod
def getNewWindow(cls,
targetImage=None,
axeSize=500,
layer=None,
parent=None):
wdgt = rawForm(axeSize=axeSize,
targetImage=targetImage,
layer=layer,
parent=parent)
wdgt.setWindowTitle(layer.name)
return wdgt
@staticmethod
def slider2Temp(v):
return 2000 + v * v
@staticmethod
def temp2Slider(T):
return np.sqrt(T - 2000)
@staticmethod
def slider2Tint(v):
return 0.1 + 0.0125 * v # 0.2 + 0.0125 * v # wanted range : 0.2...2.5
# coeff = (self.tempCorrection / 4000 - 1) * 1.2 # experimental formula
# eturn coeff + 0.01*v
@staticmethod
def tint2Slider(t):
return (t - 0.1) / 0.0125
# coeff = (self.tempCorrection / 4000 - 1) * 1.2 # experimental formula
# return (t-coeff)/0.01
# displayed value
@staticmethod
def sliderTint2User(v):
return v - 75 # ((slider2Tint(v) - 1)*100)
@staticmethod
def slider2Exp(v):
return 2**((v - 50) / 15.0)
@staticmethod
def exp2Slider(e):
return round(15 * np.log2(e) + 50)
@staticmethod
def sliderExp2User(v):
return (v - 50) / 15
@staticmethod
def slider2Cont(v):
return v
@staticmethod
def cont2Slider(e):
return e
@staticmethod
def slider2Br(v):
return (np.power(3, v / 50) - 1) / 2
@staticmethod
def br2Slider(v):
return 50 * log(2 * v + 1, 3) # int(round(50.0 * e))
@staticmethod
def brSlider2User(v):
return v - 50
@staticmethod
def slider2Sat(v):
return v - 50
@staticmethod
def sat2Slider(e):
return e + 50
def __init__(self, targetImage=None, axeSize=500, layer=None, parent=None):
super().__init__(layer=layer, targetImage=targetImage, parent=parent)
#######################################
# Libraw correspondences:
# rgb_xyz_matrix is libraw cam_xyz
# camera_whitebalance is libraw cam_mul
# daylight_whitebalance is libraw pre_mul
# dng correspondences:
# ASSHOTNEUTRAL tag value is (X,Y,Z) = 1 / rawpyObj.camera_whitebalance
##########################################
rawpyObj = layer.parentImage.rawImage
# constants and as shot values
self.XYZ2CameraMatrix = rawpyObj.rgb_xyz_matrix[:3, :]
self.XYZ2CameraInverseMatrix = np.linalg.inv(self.XYZ2CameraMatrix)
# initial post processing multipliers (as shot)
m1, m2, m3, m4 = rawpyObj.camera_whitebalance
self.asShotMultipliers = (
m1 / m2, 1.0, m3 / m2, m4 / m2
) # normalization is mandatory : for nef files white balance is around 256
self.asShotTemp, self.asShotTint = multipliers2TemperatureAndTint(
*1 / np.array(self.asShotMultipliers[:3]), self.XYZ2CameraMatrix)
self.rawMultipliers = self.asShotMultipliers # rawpyObj.camera_whitebalance # = 1/(dng ASSHOTNEUTRAL tag value)
self.sampleMultipliers = False
self.samples = []
########################################
# XYZ-->Camera conversion matrix:
# Last row is zero for RGB cameras (cf. rawpy and libraw docs).
# type ndarray, shape (4,3)
#########################################
# attributes initialized in setDefaults, declared here for the sake of correctness
self.tempCorrection, self.tintCorrection, self.expCorrection, self.highCorrection,\
self.contCorrection, self.satCorrection, self.brCorrection = [None] * 7
# contrast spline vie (initialized by setContrastSpline)
self.contrastForm = None
# tone spline view (initialized by setToneSpline)
self.toneForm = None
# dock containers for contrast and tome forms
self.dockC, self.dockT = None, None
# options
optionList0, optionNames0 = ['Auto Brightness', 'Preserve Highlights'
], ['Auto Expose', 'Preserve Highlights']
optionList1, optionNames1 = ['Auto WB', 'Camera WB', 'User WB'
], ['Auto', 'Camera (As Shot)', 'User']
optionList2, optionNames2 = [
'cpLookTable', 'cpToneCurve', 'manualCurve'
], [
'Use Camera Profile Look Table', 'Show Tone Curves',
'Show Contrast Curve'
]
self.listWidget1 = optionsWidget(
options=optionList0,
optionNames=optionNames0,
exclusive=False,
changed=lambda: self.dataChanged.emit(1))
self.listWidget2 = optionsWidget(
options=optionList1,
optionNames=optionNames1,
exclusive=True,
changed=lambda: self.dataChanged.emit(1))
self.listWidget3 = optionsWidget(
options=optionList2,
optionNames=optionNames2,
exclusive=False,
changed=lambda: self.dataChanged.emit(2))
self.options = UDict(
(self.listWidget1.options, self.listWidget2.options,
self.listWidget3.options))
# display the 'as shot' temperature
item = self.listWidget2.item(1)
item.setText(item.text() + ' : %d' % self.asShotTemp)
# temperature slider
self.sliderTemp = QbLUeSlider(Qt.Horizontal)
self.sliderTemp.setStyleSheet(
QbLUeSlider.bLueSliderDefaultColorStylesheet)
self.sliderTemp.setRange(0, 100)
self.sliderTemp.setSingleStep(1)
self.tempLabel = QLabel()
self.tempLabel.setText("Temp")
self.tempValue = QLabel()
font = self.tempValue.font()
metrics = QFontMetrics(font)
w = metrics.width("10000")
h = metrics.height()
self.tempValue.setMinimumSize(w, h)
self.tempValue.setMaximumSize(w, h)
self.tempValue.setText(
str("{:.0f}".format(self.slider2Temp(self.sliderTemp.value()))))
self.sliderTemp.valueChanged.connect(
self.tempUpdate) # signal send new value as parameter
self.sliderTemp.sliderReleased.connect(lambda: self.tempUpdate(
self.sliderTemp.value())) # signal pass no parameter
# tint slider
self.sliderTint = QbLUeSlider(Qt.Horizontal)
self.sliderTint.setStyleSheet(
QbLUeSlider.bLueSliderDefaultIMGColorStylesheet)
self.sliderTint.setRange(0, 150)
self.sliderTint.setSingleStep(1)
self.tintLabel = QLabel()
self.tintLabel.setText("Tint")
self.tintValue = QLabel()
font = self.tempValue.font()
metrics = QFontMetrics(font)
w = metrics.width("100")
h = metrics.height()
self.tintValue.setMinimumSize(w, h)
self.tintValue.setMaximumSize(w, h)
self.tintValue.setText(
str("{:.0f}".format(self.sliderTint2User(
self.sliderTint.value()))))
self.sliderTint.valueChanged.connect(self.tintUpdate)
self.sliderTint.sliderReleased.connect(lambda: self.tintUpdate(
self.sliderTint.value())) # signal pass no parameter)
######################
# From libraw and dcraw sources:
# Exposure and brightness are curve transformations.
# Exposure curve is y = alpha*x, with cubic root ending; it is applied before demosaicing.
# Brightness is (similar to) y = x**alpha and part of gamma transformation from linear sRGB to RGB.
# Exposure and brightness both dilate the histogram towards highlights.
# Exposure dilatation is uniform (homothety), brightness dilataion is
# maximum for the midtones and the highlghts are preserved.
# As a consequence, normal workflow begins with the adjustment of exposure,
# to fill the entire range of the histogram and to adjust the highlights. Next,
# one adjusts the brightness to put the midtones at the level we want them to be.
# Cf. https://www.cambridgeincolour.com/forums/thread653.htm
#####################
# profile combo
self.dngDict = self.setCameraProfilesCombo()
# cameraProfilesCombo index changed event handler
def cameraProfileUpdate(value):
self.dngDict = self.cameraProfilesCombo.itemData(value)
if self.options['cpToneCurve']:
toneCurve = dngProfileToneCurve(
self.dngDict.get('ProfileToneCurve', []))
self.toneForm.baseCurve = [
QPointF(x * axeSize, -y * axeSize)
for x, y in zip(toneCurve.dataX, toneCurve.dataY)
]
self.toneForm.update()
# recompute as shot temp and tint using new profile
self.asShotTemp, self.asShotTint = multipliers2TemperatureAndTint(
*1 / np.array(self.asShotMultipliers[:3]),
self.XYZ2CameraMatrix,
dngDict=self.dngDict
) # TODO 6/12/19 added keyword dngDict validate
# display updated as shot temp
item = self.listWidget2.item(1)
item.setText(item.text().split(":")[0] + ': %d' % self.asShotTemp)
# invalidate cache
self.layer.bufCache_HSV_CV32 = None
self.dataChanged.emit(2) # 2 = no postprocessing
self.cameraProfilesCombo.currentIndexChanged.connect(
cameraProfileUpdate)
# denoising combo
self.denoiseCombo = QComboBox()
items = OrderedDict([('Off', 0), ('Medium', 1), ('Full', 2)])
for key in items:
self.denoiseCombo.addItem(key, items[key])
# denoiseCombo index changed event handler
def denoiseUpdate(value):
self.denoiseValue = self.denoiseCombo.itemData(value)
self.dataChanged.emit(1)
self.denoiseCombo.currentIndexChanged.connect(denoiseUpdate)
# overexposed area restoration
self.overexpCombo = QComboBox()
items = OrderedDict([('Clip', 0), ('Ignore', 1), ('Blend', 2),
('Reconstruct', 3)])
for key in items:
self.overexpCombo.addItem(key, items[key])
# overexpCombo index changed event handler
def overexpUpdate(value):
self.overexpValue = self.overexpCombo.itemData(value)
self.dataChanged.emit(1)
self.overexpCombo.currentIndexChanged.connect(overexpUpdate)
# exp slider
self.sliderExp = QbLUeSlider(Qt.Horizontal)
self.sliderExp.setStyleSheet(QbLUeSlider.bLueSliderDefaultBWStylesheet)
self.sliderExp.setRange(0, 100)
self.sliderExp.setSingleStep(1)
self.expLabel = QLabel()
self.expLabel.setText("Exp.")
self.expValue = QLabel()
font = self.expValue.font()
metrics = QFontMetrics(font)
w = metrics.width("+1.0")
h = metrics.height()
self.expValue.setMinimumSize(w, h)
self.expValue.setMaximumSize(w, h)
self.expValue.setText(
str("{:.1f}".format(self.slider2Exp(self.sliderExp.value()))))
# exp done event handler
def expUpdate(value):
self.expValue.setText(
str("{:+.1f}".format(
self.sliderExp2User(self.sliderExp.value()))))
# move not yet terminated or value not modified
if self.sliderExp.isSliderDown() or self.slider2Exp(
value) == self.expCorrection:
return
try:
self.sliderExp.valueChanged.disconnect()
self.sliderExp.sliderReleased.disconnect()
except RuntimeError:
pass
# rawpy: expCorrection range is -2.0...3.0, boiling down to exp_shift range 2**(-2)=0.25...2**3=8.0
self.expCorrection = self.slider2Exp(self.sliderExp.value())
self.dataChanged.emit(1)
self.sliderExp.valueChanged.connect(
expUpdate) # send new value as parameter
self.sliderExp.sliderReleased.connect(lambda: expUpdate(
self.sliderExp.value())) # signal pass no parameter
self.sliderExp.valueChanged.connect(
expUpdate) # send new value as parameter
self.sliderExp.sliderReleased.connect(lambda: expUpdate(
self.sliderExp.value())) # signal pass no parameter
# brightness slider
brSlider = QbLUeSlider(Qt.Horizontal)
brSlider.setRange(1, 101)
self.sliderExp.setSingleStep(1)
brSlider.setStyleSheet(QbLUeSlider.bLueSliderDefaultBWStylesheet)
self.sliderBrightness = brSlider
brLabel = QLabel()
brLabel.setText("Bright.")
self.brValue = QLabel()
font = self.expValue.font()
metrics = QFontMetrics(font)
w = metrics.width("+99")
h = metrics.height()
self.brValue.setMinimumSize(w, h)
self.brValue.setMaximumSize(w, h)
self.brValue.setText(
str("{:+d}".format(
int(self.brSlider2User(self.sliderBrightness.value())))))
# brightness done event handler
def brUpdate(value):
self.brValue.setText(
str("{:+d}".format(
int(self.brSlider2User(self.sliderBrightness.value())))))
# move not yet terminated or value not modified
if self.sliderBrightness.isSliderDown() or self.slider2Br(
value) == self.brCorrection:
return
try:
self.sliderBrightness.valueChanged.disconnect()
self.sliderBrightness.sliderReleased.disconnect()
except RuntimeError:
pass
self.brCorrection = self.slider2Br(self.sliderBrightness.value())
self.dataChanged.emit(1)
self.sliderBrightness.sliderReleased.connect(
lambda: brUpdate(self.sliderBrightness.value()))
self.sliderBrightness.valueChanged.connect(
brUpdate) # send new value as parameter
self.sliderBrightness.valueChanged.connect(
brUpdate) # send new value as parameter
self.sliderBrightness.sliderReleased.connect(
lambda: brUpdate(self.sliderBrightness.value()))
# contrast slider
self.sliderCont = QbLUeSlider(Qt.Horizontal)
self.sliderCont.setStyleSheet(
QbLUeSlider.bLueSliderDefaultBWStylesheet)
self.sliderCont.setRange(0, 20)
self.sliderCont.setSingleStep(1)
self.contLabel = QLabel()
self.contLabel.setText("Cont.")
self.contValue = QLabel()
font = self.contValue.font()
metrics = QFontMetrics(font)
w = metrics.width("100")
h = metrics.height()
self.contValue.setMinimumSize(w, h)
self.contValue.setMaximumSize(w, h)
self.contValue.setText(
str("{:.0f}".format(self.slider2Cont(self.sliderCont.value()))))
# cont done event handler
def contUpdate(value):
self.contValue.setText(
str("{:.0f}".format(self.slider2Cont(
self.sliderCont.value()))))
# move not yet terminated or value not modified
if self.sliderCont.isSliderDown() or self.slider2Cont(
value) == self.tempCorrection:
return
try:
self.sliderCont.valueChanged.disconnect()
self.sliderCont.sliderReleased.disconnect()
except RuntimeError:
pass
self.contCorrection = self.slider2Cont(self.sliderCont.value())
self.contValue.setText(str("{:+d}".format(self.contCorrection)))
# force to recalculate the spline
self.layer.autoSpline = True
self.dataChanged.emit(
3) # no postprocessing and no camera profile stuff
self.sliderCont.valueChanged.connect(
contUpdate) # send new value as parameter
self.sliderCont.sliderReleased.connect(lambda: contUpdate(
self.sliderCont.value())) # signal has no parameter
self.sliderCont.valueChanged.connect(
contUpdate) # send new value as parameter
self.sliderCont.sliderReleased.connect(lambda: contUpdate(
self.sliderCont.value())) # signal has no parameter
# saturation slider
self.sliderSat = QbLUeSlider(Qt.Horizontal)
self.sliderSat.setStyleSheet(
QbLUeSlider.bLueSliderDefaultColorStylesheet)
self.sliderSat.setRange(0, 100)
self.sliderSat.setSingleStep(1)
satLabel = QLabel()
satLabel.setText("Sat.")
self.satValue = QLabel()
font = self.satValue.font()
metrics = QFontMetrics(font)
w = metrics.width("+10")
h = metrics.height()
self.satValue.setMinimumSize(w, h)
self.satValue.setMaximumSize(w, h)
self.satValue.setText(
str("{:+d}".format(self.slider2Sat(self.sliderSat.value()))))
"""sat done event handler"""
def satUpdate(value):
self.satValue.setText(
str("{:+d}".format(self.slider2Sat(self.sliderSat.value()))))
# move not yet terminated or value not modified
if self.sliderSat.isSliderDown() or self.slider2Sat(
value) == self.satCorrection:
return
try:
self.sliderSat.valueChanged.disconnect()
self.sliderSat.sliderReleased.disconnect()
except RuntimeError:
pass
self.satCorrection = self.slider2Sat(self.sliderSat.value())
self.dataChanged.emit(
3) # no post processing and no camera profile stuff
self.sliderSat.valueChanged.connect(
satUpdate) # send new value as parameter
self.sliderSat.sliderReleased.connect(lambda: satUpdate(
self.sliderSat.value())) # signal has no parameter
self.sliderSat.valueChanged.connect(
satUpdate) # send new value as parameter
self.sliderSat.sliderReleased.connect(lambda: satUpdate(
self.sliderSat.value())) # signal has no parameter
# layout
l = QVBoxLayout()
l.addWidget(self.listWidget3)
hl01 = QHBoxLayout()
hl01.addWidget(QLabel('Camera Profile'))
hl01.addWidget(self.cameraProfilesCombo)
l.addLayout(hl01)
hl0 = QHBoxLayout()
hl0.addWidget(QLabel('Denoising'))
hl0.addWidget(self.denoiseCombo)
l.addLayout(hl0)
hl00 = QHBoxLayout()
hl00.addWidget(QLabel('Overexp. Restoration'))
hl00.addWidget(self.overexpCombo)
l.addLayout(hl00)
hl1 = QHBoxLayout()
hl1.addWidget(self.expLabel)
hl1.addWidget(self.expValue)
hl1.addWidget(self.sliderExp)
l.addLayout(hl1)
hl8 = QHBoxLayout()
hl8.addWidget(brLabel)
hl8.addWidget(self.brValue)
hl8.addWidget(self.sliderBrightness)
l.addLayout(hl8)
l.addWidget(self.listWidget1)
vl1 = QVBoxLayout()
vl1.addWidget(self.listWidget2)
gb1 = QGroupBox()
gb1.setTitle('White Balance')
hl2 = QHBoxLayout()
hl2.addWidget(self.tempLabel)
hl2.addWidget(self.tempValue)
hl2.addWidget(self.sliderTemp)
hl3 = QHBoxLayout()
hl3.addWidget(self.tintLabel)
hl3.addWidget(self.tintValue)
hl3.addWidget(self.sliderTint)
vl1.addLayout(hl2)
vl1.addLayout(hl3)
gb1.setLayout(vl1)
l.addWidget(gb1)
hl4 = QHBoxLayout()
hl4.addWidget(self.contLabel)
hl4.addWidget(self.contValue)
hl4.addWidget(self.sliderCont)
hl7 = QHBoxLayout()
hl7.addWidget(satLabel)
hl7.addWidget(self.satValue)
hl7.addWidget(self.sliderSat)
# separator
sep = QFrame()
sep.setFrameShape(QFrame.HLine)
sep.setFrameShadow(QFrame.Sunken)
l.addWidget(sep)
l.addLayout(hl4)
l.addLayout(hl7)
l.addStretch(1)
self.setLayout(l)
self.adjustSize()
self.setDefaults()
self.setWhatsThis("""<b>Development of raw files</b><br>
<b>Default settings</b> are a good starting point.<br>
A <b>Tone Curve</b> is applied to the raw image prior to postprocessing.<br>
The cuvre can be edited by checking the option
<b>Show Tone Curve</b>; this option works best with manual exposure.<br>
<b>Contrast</b> correction is based on an automatic algorithm
well suited to multi-mode histograms.<br>
<b>Brightness, Contrast</b> and <b>Saturation</b> levels</b> are
adjustable with the correponding sliders.<br>
The <b>Contrast Curve</b> can be edited manually by checking
the option <b>Show Contrast Curve</b>.<br>
Uncheck <b>Auto Expose</b> to adjust the exposure manually.<br>
The <b>OverExp. Rest.</b> slider controls the mode of restoration of overexposed areas.
Valid values are 0 to 3 (0=clip;1=unclip;2=blend;3=rebuild); (with Auto Exposed
checked the mode is clip).<br>
""") # end of setWhatsThis
def close(self):
"""
Overrides QWidget.close to
close toneForm and contrastForm
@return:
@rtype: boolean
"""
delete = self.testAttribute(Qt.WA_DeleteOnClose)
for attr in ['toneForm', 'contrastForm']:
form = getattr(self, attr, None)
if delete and form is not None:
dock = form.parent()
dock.setAttribute(Qt.WA_DeleteOnClose)
form.setAttribute(Qt.WA_DeleteOnClose)
dock.close()
form.close()
return super().close()
def showToneSpline(self):
"""
On first call, init and show the Tone Curve form.
Otherwise, show the form.
Return True if called for the first time, False otherwise.
@return:
@rtype: boolean
"""
axeSize = 200
if self.toneForm is None:
form = graphicsToneForm.getNewWindow(targetImage=self.targetImage,
axeSize=axeSize,
layer=self.layer,
parent=self,
curveType='cubic')
form.setWindowFlags(Qt.WindowStaysOnTopHint)
form.setAttribute(Qt.WA_DeleteOnClose, on=False)
form.setFixedHeight(axeSize + 140)
form.setWindowTitle('Cam Tone Curve')
form.setButtonText('Reset Curve')
# get base curve from profile
toneCurve = dngProfileToneCurve(
self.dngDict.get('ProfileToneCurve', []))
form.baseCurve = [
QPointF(x * axeSize, -y * axeSize)
for x, y in zip(toneCurve.dataX, toneCurve.dataY)
]
def f():
layer = self.layer
layer.bufCache_HSV_CV32 = None
layer.applyToStack()
layer.parentImage.onImageChanged()
form.scene().quadricB.curveChanged.sig.connect(f)
self.toneForm = form
self.toneForm.optionName = 'cpToneCurve'
dockT = self.addSubcontrol(
self.parent()) # )stateAwareQDockWidget(self.parent())
dockT.setWindowFlags(form.windowFlags())
dockT.setWindowTitle(form.windowTitle())
dockT.setStyleSheet(
"QGraphicsView{margin: 10px; border-style: solid; border-width: 1px; border-radius: 1px;}"
)
window = self.parent().parent()
window.addDockWidget(Qt.LeftDockWidgetArea, dockT)
self.dockT = dockT
dockT.setWidget(form)
showFirst = True
form.setWhatsThis("""<b>Camera Profile Tone Curve</b><br>
The profile curve, if any, is applied as a starting point for user adjustments,
after raw post-processing.
Its input and output are in <b>linear</b> gamma.
The curve is shown in red and cannot be changed.<br>
A user curve, shown in black, is editable and is applied right after the
former.<br>
""") # end of setWhatsThis
else:
form = self.toneForm
showFirst = False
form.scene().setSceneRect(-25, -axeSize - 25, axeSize + 50,
axeSize + 50)
self.dockT.showNormal()
return showFirst
def setContrastSpline(self, a, b, d, T):
"""
Updates and displays the contrast spline Form.
The form is created if needed.
(Cf. also CoBrStaForm setContrastSpline).
@param a: x_coordinates
@type a:
@param b: y-coordinates
@type b:
@param d: tangent slopes
@type d:
@param T: spline
@type T: ndarray dtype=float
"""
axeSize = 200
if self.contrastForm is None:
form = graphicsSplineForm.getNewWindow(targetImage=None,
axeSize=axeSize,
layer=self.layer,
parent=None)
form.setFixedHeight(axeSize + 140)
form.setWindowFlags(Qt.WindowStaysOnTopHint)
form.setAttribute(Qt.WA_DeleteOnClose, on=False)
form.setWindowTitle('Contrast Curve')
def f():
layer = self.layer
layer.applyToStack()
layer.parentImage.onImageChanged()
form.scene().quadricB.curveChanged.sig.connect(f)
self.contrastForm = form
self.contrastForm.optionName = 'manualCurve'
dockC = self.addSubcontrol(
self.parent()) # stateAwareQDockWidget(self.parent())
dockC.setWindowFlags(form.windowFlags())
dockC.setWindowTitle(form.windowTitle())
dockC.setStyleSheet(
"QGraphicsView{margin: 10px; border-style: solid; border-width: 1px; border-radius: 1px;}"
)
window = self.parent().parent()
window.addDockWidget(Qt.LeftDockWidgetArea, dockC)
self.dockC = dockC
dockC.setWidget(form)
else:
form = self.contrastForm
# update the curve
form.scene().setSceneRect(-25, -axeSize - 25, axeSize + 50,
axeSize + 50)
form.scene().quadricB.setCurve(a * axeSize, b * axeSize, d,
T * axeSize)
self.dockC.showNormal()
# temp changed event handler
def tempUpdate(self, value):
self.tempValue.setText(
str("{:.0f}".format(self.slider2Temp(self.sliderTemp.value()))))
# move not yet terminated or value not modified
if self.sliderTemp.isSliderDown() or self.slider2Temp(
value) == self.tempCorrection:
return
try:
self.sliderTemp.valueChanged.disconnect()
self.sliderTemp.sliderReleased.disconnect()
except RuntimeError:
pass
self.tempCorrection = self.slider2Temp(self.sliderTemp.value())
# get multipliers (temperatureAndTint2Multipliers returns the camera neutral)
multipliers = [
1 / m
for m in temperatureAndTint2Multipliers(self.tempCorrection,
1.0,
self.XYZ2CameraMatrix,
dngDict=self.dngDict)
] # TODO 6/12/19 added keyword dngDict validate
multipliers[1] *= self.tintCorrection
self.rawMultipliers = multipliers
m = multipliers[1]
self.rawMultipliers = [self.rawMultipliers[i] / m for i in range(4)]
self.dataChanged.emit(1)
self.sliderTemp.valueChanged.connect(
self.tempUpdate) # send new value as parameter
self.sliderTemp.sliderReleased.connect(lambda: self.tempUpdate(
self.sliderTemp.value())) # signal has no parameter
# tint change event handler
def tintUpdate(self, value):
self.tintValue.setText(
str("{:.0f}".format(self.sliderTint2User(
self.sliderTint.value()))))
# move not yet terminated or value not modified
if self.sliderTint.isSliderDown() or self.slider2Tint(
value) == self.tintCorrection:
return
try:
self.sliderTint.valueChanged.disconnect()
self.sliderTint.sliderReleased.disconnect()
except RuntimeError:
pass
self.tintCorrection = self.slider2Tint(self.sliderTint.value())
# get multipliers (temperatureAndTint2Multipliers returns the camera neutral)
multipliers = [
1 / m
for m in temperatureAndTint2Multipliers(self.tempCorrection,
1.0,
self.XYZ2CameraMatrix,
dngDict=self.dngDict)
] # TODO 6/12/19 added keyword dngDict validate
multipliers[1] *= self.tintCorrection
self.rawMultipliers = multipliers
m = multipliers[1]
self.rawMultipliers = [self.rawMultipliers[i] / m for i in range(4)]
self.dataChanged.emit(1)
self.sliderTint.valueChanged.connect(self.tintUpdate)
self.sliderTint.sliderReleased.connect(lambda: self.tintUpdate(
self.sliderTint.value())) # signal has no parameter)
def setRawMultipliers(self, m0, m1, m2, sampling=True):
mi = min(m0, m1, m2)
m0, m1, m2 = m0 / mi, m1 / mi, m2 / mi
self.rawMultipliers = [m0, m1, m2, m1]
invMultipliers = [1 / self.rawMultipliers[i] for i in range(3)]
try:
self.sliderTemp.valueChanged.disconnect()
self.sliderTint.valueChanged.disconnect()
except RuntimeError:
pass
# get temp and tint
temp, tint = multipliers2TemperatureAndTint(*invMultipliers,
self.XYZ2CameraMatrix)
self.tintCorrection = tint
self.sliderTemp.setValue(self.temp2Slider(temp))
self.sliderTint.setValue(self.tint2Slider(tint))
self.tempValue.setText(
str("{:.0f}".format(self.slider2Temp(self.sliderTemp.value()))))
self.tintValue.setText(
str("{:.0f}".format(self.sliderTint2User(
self.sliderTint.value()))))
self.sliderTemp.valueChanged.connect(self.tempUpdate)
self.sliderTint.valueChanged.connect(self.tintUpdate)
self.sampleMultipliers = sampling
self.dataChanged.emit(1)
def updateLayer(self, level):
"""
data changed event handler.
@param level: 3: redo contrast and saturation, 2: previous + camera profile stuff, 1: all
@type level: int
"""
if level == 1:
# force all
self.layer.bufCache_HSV_CV32 = None
self.layer.postProcessCache = None
elif level == 2:
# force camera profile stuff
self.layer.bufCache_HSV_CV32 = None
elif level == 3:
# keep the 2 cache buffers
pass
# contrast curve
cf = getattr(self, 'dockC', None)
if cf is not None:
if self.options['manualCurve']:
cf.showNormal()
else:
cf.hide()
# tone curve
ct = getattr(self, 'dockT', None)
if ct is not None:
if self.options['cpToneCurve']:
ct.showNormal()
else:
ct.hide()
self.enableSliders()
self.layer.applyToStack()
self.layer.parentImage.onImageChanged()
def enableSliders(self):
useUserWB = self.listWidget2.options["User WB"]
useUserExp = not self.listWidget1.options["Auto Brightness"]
self.sliderTemp.setEnabled(useUserWB)
self.sliderTint.setEnabled(useUserWB)
self.sliderExp.setEnabled(useUserExp)
# self.sliderHigh.setEnabled(useUserExp)
self.tempValue.setEnabled(self.sliderTemp.isEnabled())
self.tintValue.setEnabled(self.sliderTint.isEnabled())
self.expValue.setEnabled(self.sliderExp.isEnabled())
# self.highValue.setEnabled(self.sliderHigh.isEnabled())
self.tempLabel.setEnabled(self.sliderTemp.isEnabled())
self.tintLabel.setEnabled(self.sliderTint.isEnabled())
self.expLabel.setEnabled(self.sliderExp.isEnabled())
# self.highLabel.setEnabled(self.sliderHigh.isEnabled())
def setDefaults(self):
self.dngDict = self.cameraProfilesCombo.itemData(0)
self.listWidget1.unCheckAll()
self.listWidget2.unCheckAll()
self.listWidget1.checkOption(self.listWidget1.intNames[0])
self.listWidget1.checkOption(self.listWidget1.intNames[1])
self.listWidget2.checkOption(self.listWidget2.intNames[1])
self.listWidget3.checkOption(self.listWidget3.intNames[0])
self.enableSliders()
self.denoiseValue = 0 # denoising off
self.overexpValue = 0 # clip
self.tempCorrection = self.asShotTemp
self.tintCorrection = 1.0
self.expCorrection = 1.0
# self.highCorrection = 3.0 # restoration of overexposed highlights. 0: clip 1:unclip, 2: blend, 3...: rebuild
self.contCorrection = 0.0
# self.noiseCorrection = 0
self.satCorrection = 0.0
self.brCorrection = 1.0
# prevent multiple updates
try:
self.dataChanged.disconnect()
except RuntimeError:
pass
self.sliderTemp.setValue(round(self.temp2Slider(self.tempCorrection)))
self.sliderTint.setValue(round(self.tint2Slider(self.tintCorrection)))
self.sliderExp.setValue(self.exp2Slider(self.expCorrection))
# self.sliderHigh.setValue(self.highCorrection)
self.sliderCont.setValue(self.cont2Slider(self.contCorrection))
self.sliderBrightness.setValue(self.br2Slider(self.brCorrection))
self.sliderSat.setValue(self.sat2Slider(self.satCorrection))
self.dataChanged.connect(self.updateLayer)
def setCameraProfilesCombo(self):
"""
Populates the camera profile Combo box.
for each item, text is the filename and data is the corresponding dict.
The function returns as soon as a first item is loaded. Remainning profiles are
loaded asynchronously.
@return: the currently selected item data
@rtype: dict
"""
self.cameraProfilesCombo = QComboBox()
files = [self.targetImage.filename]
files.extend(getDngProfileList(self.targetImage.cameraModel()))
if not files:
self.cameraProfilesCombo.addItem('None', {})
return {}
# load a first profile
nextInd, found = 0, False
while nextInd < len(files) and not found:
f = files[nextInd]
key = basename(f)[:-4] if nextInd > 0 else 'Embedded Profile'
d = getDngProfileDict(f)
# filter d
d = {k: d[k] for k in d if d[k] != ''}
if d:
self.cameraProfilesCombo.addItem(key, d)
found = True
nextInd += 1
def load():
# load remaining profiles
for i, f in enumerate(files[nextInd:]):
key = basename(
f)[:-4] if i + nextInd > 0 else 'Embedded Profile'
d = getDngProfileDict(f)
# filter d
d = {k: d[k] for k in d if d[k] != ''}
if d:
self.cameraProfilesCombo.addItem(key, d)
self.cameraProfilesCombo.addItem('None', {})
threading.Thread(target=load).start()
self.cameraProfilesCombo.setSizeAdjustPolicy(
QComboBox.SizeAdjustPolicy.AdjustToContents)
self.cameraProfilesCombo.setMaximumWidth(150)
self.cameraProfilesCombo.setStyleSheet(
"QComboBox QAbstractItemView { min-width: 250px;}")
# return the currently selected item data
return self.cameraProfilesCombo.itemData(0)
class QTgoLayoutGroupRow(QWidget):
group_template_changed = Signal()
def __init__(self, force_group: ForceGroup, group: TgoLayoutGroup) -> None:
super().__init__()
self.grid_layout = QGridLayout()
self.setLayout(self.grid_layout)
self.grid_layout.setColumnStretch(0, 100)
self.amount_selector = QSpinBox()
self.unit_selector = QComboBox()
self.unit_selector.setMinimumWidth(250)
self.group_selector = QCheckBox()
# Add all possible units with the price
for unit_type in force_group.unit_types_for_group(group):
self.unit_selector.addItem(
f"{unit_type.name} [${unit_type.price}M]",
userData=(unit_type.dcs_unit_type, unit_type.price),
)
# Add all possible statics with price = 0
for static_type in force_group.statics_for_group(group):
self.unit_selector.addItem(f"{static_type} (Static)",
userData=(static_type, 0))
if self.unit_selector.count() == 0:
raise LayoutException("No units available for the TgoLayoutGroup")
self.unit_selector.adjustSize()
self.unit_selector.setEnabled(self.unit_selector.count() > 1)
self.grid_layout.addWidget(self.unit_selector,
0,
0,
alignment=Qt.AlignRight)
self.grid_layout.addWidget(self.amount_selector,
0,
1,
alignment=Qt.AlignRight)
dcs_unit_type, price = self.unit_selector.itemData(
self.unit_selector.currentIndex())
self.group_layout = QTgoLayoutGroup(group, dcs_unit_type,
group.group_size, price)
self.group_selector.setChecked(self.group_layout.enabled)
self.group_selector.setEnabled(self.group_layout.layout.optional)
self.amount_selector.setMinimum(1)
self.amount_selector.setMaximum(self.group_layout.layout.max_size)
self.amount_selector.setValue(self.group_layout.amount)
self.amount_selector.setEnabled(self.group_layout.layout.max_size > 1)
self.grid_layout.addWidget(self.group_selector,
0,
2,
alignment=Qt.AlignRight)
self.amount_selector.valueChanged.connect(self.on_group_changed)
self.unit_selector.currentIndexChanged.connect(self.on_group_changed)
self.group_selector.stateChanged.connect(self.on_group_changed)
def on_group_changed(self) -> None:
self.group_layout.enabled = self.group_selector.isChecked()
unit_type, price = self.unit_selector.itemData(
self.unit_selector.currentIndex())
self.group_layout.dcs_unit_type = unit_type
self.group_layout.unit_price = price
self.group_layout.amount = self.amount_selector.value()
self.group_template_changed.emit()
class SelectPlayersWindow(QDialog):
def __init__(self, parent=None):
super(SelectPlayersWindow, self).__init__(parent)
self.parent = parent
self.setModal(True)
self.setWindowTitle("Torna résztvevők")
self.resize(520, 600)
self.layout = QVBoxLayout()
self.setLayout(self.layout)
self.read_config()
self.create_torna_selection()
self.nevek_layout = QHBoxLayout()
self.layout.addLayout(self.nevek_layout)
self.show_saved_players()
self.show_torna_players()
self.gomb_nev_layout = QVBoxLayout()
self.nevek_layout.addLayout(self.gomb_nev_layout)
self.show_current_players()
self.buttonbox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.buttonbox.clicked.connect(self.buttonbox_click)
self.layout.addWidget(self.buttonbox)
def create_torna_selection(self):
self.tournaments = QComboBox()
self.tournaments.setModelColumn(0)
self.tournaments.currentIndexChanged.connect(self.torna_valasztas)
self.layout.addWidget(self.tournaments)
self.load_torna()
def load_torna(self):
torna = QSqlQueryModel()
query = QSqlQuery("select * from torna_settings where aktiv=2")
torna.setQuery(query)
if torna.record(0).value(0):
for i in range(torna.rowCount()):
self.tournaments.addItem(
torna.record(i).value(1),
torna.record(i).value(0)) # a value(0) a torna_id
else:
print("Nincs aktív torna")
def show_saved_players(self):
self.saved_players = QListWidget()
self.saved_players.setFixedHeight(500)
self.saved_players.setFixedWidth(150)
self.saved_players.setSortingEnabled(True)
self.saved_players.itemDoubleClicked.connect(self.add_resztvevo)
self.load_saved_players()
self.nevek_layout.addWidget(self.saved_players)
def show_torna_players(self):
self.torna_players = QListWidget()
self.torna_players.setFixedHeight(500)
self.torna_players.setFixedWidth(150)
self.torna_players.setSortingEnabled(True)
self.torna_players.itemDoubleClicked.connect(self.add_resztvevo)
self.load_torna_players()
self.nevek_layout.addWidget(self.torna_players)
def load_saved_players(self):
players = QSqlQueryModel()
players_query = QSqlQuery("select * from players where aktiv=1")
players.setQuery(players_query)
self.saved_players.clear()
for i in range(players.rowCount()):
item = QListWidgetItem(players.record(i).value(1))
item.setData(Qt.UserRole, players.record(i).value(0))
self.saved_players.addItem(item)
def load_torna_players(self):
players = QSqlQueryModel()
players_query = QSqlQuery(
"select * from torna_resztvevok where 1 group by player_id, player_name"
)
players.setQuery(players_query)
self.torna_players.clear()
for i in range(players.rowCount()):
item = QListWidgetItem(players.record(i).value(1))
item.setData(Qt.UserRole, players.record(i).value(0))
self.torna_players.addItem(item)
def add_resztvevo(self, item):
new_item = QListWidgetItem(item)
new_item.setData(Qt.UserRole, item.data(Qt.UserRole))
self.current_players.addItem(new_item)
query = QSqlQuery(
f"insert into torna_resztvevok (player_id, player_name, torna_id) values ({new_item.data(Qt.UserRole)}, '{new_item.text()}', {self.torna_id})"
)
query.exec_()
def show_current_players(self):
query = QSqlQuery("select max(player_id) from torna_resztvevok")
query.exec_()
while query.next():
self.first_new_id = int(query.value(0)) + 1
print(self.first_new_id)
self.add_new = QPushButton("Új")
self.add_new.clicked.connect(self.uj_ember)
self.current_players = QListWidget()
self.current_players.setFixedHeight(470)
self.current_players.setFixedWidth(150)
self.current_players.setSortingEnabled(True)
self.gomb_nev_layout.addWidget(self.add_new)
self.current_players.itemDoubleClicked.connect(self.remove_resztvevo)
self.gomb_nev_layout.addWidget(self.current_players)
def uj_ember(self):
ujember, ok = QInputDialog.getText(
self, "Új versenyző",
'<html style="font-size: 15px;">Írd be a versenyző nevét!</html>')
if ok and len(ujember):
item = QListWidgetItem(ujember)
item.setData(Qt.UserRole, self.first_new_id)
self.current_players.addItem(item)
self.first_new_id += 1
query = QSqlQuery(
f"insert into torna_resztvevok (player_id, player_name, torna_id) values ({item.data(Qt.UserRole)}, '{item.text()}', {self.torna_id})"
)
query.exec_()
def remove_resztvevo(self, item):
self.current_players.takeItem(
self.current_players.row(self.current_players.selectedItems()[0]))
# print(item.data(Qt.UserRole), item.text())
query = QSqlQuery(
f"delete from torna_resztvevok where player_id={item.data(Qt.UserRole)} and torna_id={self.torna_id}"
)
query.exec_()
def torna_valasztas(self, i):
self.torna_id = self.tournaments.itemData(i)
players = QSqlQueryModel()
players_query = QSqlQuery(
f"select * from torna_resztvevok where torna_id={self.torna_id}")
players.setQuery(players_query)
self.current_players.clear()
for i in range(players.rowCount()):
item = QListWidgetItem(players.record(i).value(1))
item.setData(Qt.UserRole, players.record(i).value(0))
self.current_players.addItem(item)
def buttonbox_click(self, b):
if b.text() == "OK":
self.accept()
elif b.text() == "Cancel":
self.reject()
def accept(self):
# for i in range(self.current_players.count()):
# item = self.current_players.item(i)
# print(self.torna_id, item.data(Qt.UserRole), item.text()) # itt vannak a beszúrandó adatok
super().accept()
# INSERT INTO `torna_resztvevok` (`player_id`, `player_name`, `torna_id`)
# VALUES ('1111', 'teszt_user2', '8892') ON DUPLICATE KEY UPDATE player_name='teszt_user2';
def read_config(self):
if os.path.exists('config.ini'):
# Van config.ini, ki kell értékelni
config.read('config.ini')
self.station_id = config['DEFAULT'].get('station id')
self.secret = config['DEFAULT'].get('secret key')
# todo módosítani kell a torna_match táblát, hogy tartalmazza a tabla mellett a hozzá tartozó secret-et is
else:
# Nincs config.ini, alapértékekkel inicializálni
msg = QMessageBox(self)
msg.setStyleSheet("fonz-size: 20px")
msg.setWindowTitle("Hiányzó beállítás file!")
msg.setText(
'<html style="font-size: 14px; color: red">Nem tudtam beolvasni a konfigurációt!<br></html>'
+
'<html style="font-size: 16px">Kérem módosítsa a beállításokat!</html>'
)
msg.exec_()
sys.exit(1)
class TornaStatuszWindow(QDialog):
def __init__(self, parent=None):
super(TornaStatuszWindow, self).__init__(parent)
self.setWindowTitle("Torna állása")
self.setMinimumHeight(720)
# self.setMinimumWidth(700)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.hatter = QVBoxLayout()
self.setLayout(self.hatter)
self.create_torna_selection()
self.hatter.addWidget(self.tournaments)
self.space = QSpacerItem(0, 0, QSizePolicy.Minimum,
QSizePolicy.Expanding)
self.hatter.addItem(self.space)
def create_torna_selection(self):
self.tournaments = QComboBox()
self.tournaments.setMinimumWidth(700)
self.tournaments.setModelColumn(0)
self.tournaments.activated.connect(self.torna_valasztas)
self.load_torna()
def load_torna(self):
torna = QSqlQueryModel()
query = QSqlQuery("select * from torna_settings where aktiv=1")
torna.setQuery(query)
if torna.record(0).value(0):
for i in range(torna.rowCount()):
self.tournaments.addItem(
torna.record(i).value(1),
torna.record(i).value(0)) # a value(0) a torna_id
def torna_valasztas(self, i):
self.torna_id = self.tournaments.itemData(i)
torna = QSqlQuery(
f"select * from torna_settings where torna_id={self.torna_id}")
torna.exec_()
while torna.next():
self.csoportok_szama = torna.value(3)
self.sorok_szama = torna.value(4)
self.variant = torna.value(5)
self.sets = torna.value(7)
self.legsperset = torna.value(8)
self.nyereshez_kell = torna.value(8)
self.pont_gyozelem = torna.value(11)
self.pont_vereseg = torna.value(13)
self.tablak = []
for cs in range(self.csoportok_szama):
tablasor = []
for sor in range(self.sorok_szama):
tablasor.append(0)
self.tablak.append(tablasor)
query2 = QSqlQuery(
f"select * from torna_tablak where torna_id={self.torna_id}")
query2.exec_()
while query2.next():
self.tablak[query2.value(2)][query2.value(3)] = query2.value(1)
self.nevek = []
for cs in range(self.csoportok_szama):
neveksor = []
for sor in range(self.sorok_szama):
neveksor.append("")
self.nevek.append(neveksor)
query2 = QSqlQuery(
f"select player_id, player_name from torna_resztvevok where torna_id={self.torna_id}"
)
query2.exec_()
while query2.next():
for x in range(self.csoportok_szama):
for y in range(self.sorok_szama):
if query2.value(0) == self.tablak[x][y]:
self.nevek[x][y] = query2.value(1)
self.create_widgets()
self.set_layout()
def create_widgets(self):
# GroupMemberWidget-ek
self.csoportok = []
for i in range(self.csoportok_szama): # Csoportok száma
self.csoportoszlop = []
for j in range(self.sorok_szama): # fő/csoport
self.csoportoszlop.append(GroupMemberWidget(self))
self.csoportoszlop[j]._set_csoport_number(i)
self.csoportoszlop[j]._set_csoport_sor(j)
self.csoportoszlop[j]._set_player_id(self.tablak[i][j])
self.csoportoszlop[j]._set_player_name(self.nevek[i][j])
self.csoportok.append(self.csoportoszlop)
# EredmenyWidget-ek
self.eredmenyek = []
for i in range(self.csoportok_szama):
self.csoport_eredmeny_matrix = []
for j in range(
self.sorok_szama): # ami egyenlő az oszlopok számával!!!
self.eredmeny_oszlop = []
for x in range(self.sorok_szama):
self.eredmeny_oszlop.append(EredmenyWidget(self))
self.eredmeny_oszlop[x]._set_csoport_number(i)
self.eredmeny_oszlop[x]._set_csoport_sor(j)
self.eredmeny_oszlop[x]._set_csoport_oszlop(x)
self.eredmeny_oszlop[x]._set_p1_id(self.tablak[i][j])
self.eredmeny_oszlop[x]._set_p2_id(self.tablak[i][x])
self.csoport_eredmeny_matrix.append(self.eredmeny_oszlop)
self.eredmenyek.append(self.csoport_eredmeny_matrix)
# SzumWidget-ek
self.szum_eredmenyek = []
for i in range(self.csoportok_szama): # 2
self.csoport_szum_eredmeny_matrix = []
for j in range(5): # ami egyenlő az oszlopok számával!!!
self.szum_eredmeny_oszlop = []
for x in range(self.sorok_szama):
self.szum_eredmeny_oszlop.append(SzumWidget(self))
# self.eredmeny_oszlop[x]._set_csoport_number(i)
# self.eredmeny_oszlop[x]._set_csoport_sor(x)
# self.eredmeny_oszlop[x]._set_csoport_oszlop(j)
self.szum_eredmeny_oszlop[x]._set_p_id(self.tablak[i][x])
# self.eredmeny_oszlop[x]._set_p2_id(self.tablak[i][x])
self.csoport_szum_eredmeny_matrix.append(
self.szum_eredmeny_oszlop)
self.szum_eredmenyek.append(self.csoport_szum_eredmeny_matrix)
if hasattr(self, 'refresh_button'):
pass
else:
self.refresh_button = QPushButton("Frissítés")
self.refresh_button.clicked.connect(self.update_statusz)
def set_layout(self):
if hasattr(self, 'main_layout'):
for i in reversed(range(self.main_layout.count())):
if self.main_layout.itemAt(i).widget() is not None:
self.main_layout.itemAt(i).widget().deleteLater()
for i in reversed(range(self.main_layout.count())):
if self.main_layout.itemAt(i).layout() is not None:
self.main_layout.itemAt(i).layout().deleteLater()
else:
self.main_layout = QHBoxLayout()
self.hatter.addLayout(self.main_layout)
groups = QWidget()
groups.setFixedWidth(((self.sorok_szama + 5) * 50) + 200)
widgets_layout = QVBoxLayout()
groups.setLayout(widgets_layout)
for n in range(self.csoportok_szama): # csoportok száma
locals()['csoport_layout' + str(n)] = QGridLayout(
) # Létrehozzuk az adott sorszámú csoport layout-ját
locals()['csoport_layout' + str(n)].setContentsMargins(0, 0, 0, 0)
locals()['csoport_layout' + str(n)].setHorizontalSpacing(0)
locals()['csoport_layout' + str(n)].setVerticalSpacing(0)
widgets_layout.addLayout(locals()[
'csoport_layout' +
str(n)]) # Hozzáadjuk a a layout-ot a widget_layout-hoz
locals()['csoport_layout' + str(n)].addWidget(
QLabel("Csoport_" + str(n + 1)), 0, 0, Qt.AlignHCenter)
sorok = len(self.csoportok[n])
for k in range(sorok):
locals()['csoport_layout' + str(n)].addWidget(
QLabel(str(k + 1)), 0, k + 1, Qt.AlignHCenter)
locals()['csoport_layout' + str(n)].addWidget(
QLabel("NY"), 0, sorok + 5, Qt.AlignHCenter)
locals()['csoport_layout' + str(n)].addWidget(
QLabel("V"), 0, sorok + 6, Qt.AlignHCenter)
locals()['csoport_layout' + str(n)].addWidget(
QLabel("K"), 0, sorok + 7, Qt.AlignHCenter)
locals()['csoport_layout' + str(n)].addWidget(
QLabel("P"), 0, sorok + 8, Qt.AlignHCenter)
locals()['csoport_layout' + str(n)].addWidget(
QLabel("H"), 0, sorok + 9, Qt.AlignHCenter)
for i in range(
len(self.csoportok[n])
): # len(self.csoportok[n]) : csoporton belüli sorok száma
# Végigmegyünk a sorokon : i: sorok száma, n: csoport száma
# N: HÁNYADIK CSOPORT, I: HÁNYADIK OSZLOP-OT TÖLTJÜK
# a layout 1. oszlopát feltöltjük a tömbben tárolt custom widget-ekkel
# self.csoportok[n][i] N-EDIK CSOPORT I-DIK SORÁBAN A NÉV
locals()['csoport_layout' + str(n)].addWidget(
self.csoportok[n][i], i + 1, 0)
# Itt töltjük fel az eredmény-widget-eket, és a szummákat (tombben tárolva, mint a GroupMemberWidget-ek)
# eredmenyek[n, y, i] n: csoport, y: oszlop, i: sor
for x in range(
len(self.csoportok[n])
): # Ez lesz az oszlop(max = sorok száma) x: oszlop száma
locals()['csoport_layout' + str(n)].addWidget(
self.eredmenyek[n][i][x], i + 1, x + 1)
# szum_eredmenyek[x, y, z] x: csoport, y: oszlop, z: sor
for y in range(5): # 5 kockát rakunk ki
locals()['csoport_layout' + str(n)].addWidget(
self.szum_eredmenyek[n][y][i], i + 1, 5 + x + y + 1)
# locals()['csoport_layout' + str(n)].addWidget(QLabel("Csoport_" + str(n + 1)), 0, 0)
lista_layout = QVBoxLayout()
lista_layout.addWidget(self.refresh_button)
scroll = QScrollArea()
scroll.setWidget(groups)
scroll.setFixedWidth(((self.sorok_szama + 5) * 50) + 220)
scroll.setFixedHeight(680)
self.main_layout.addWidget(scroll)
self.main_layout.addLayout(lista_layout)
def update_statusz(self):
legek = []
query = QSqlQuery(
f"SELECT matches.*,torna_match.player1_id as p1,torna_match.player2_id as p2 FROM matches,\
torna_match WHERE matches.match_id=torna_match.match_id and torna_match.torna_id={self.torna_id}"
)
query.exec_()
while query.next():
akt_leg = []
akt_leg.append(query.value(0)) # match_id
akt_leg.append(query.value(5)) # p1
akt_leg.append(query.value(6)) # p2
akt_leg.append(query.value(1)) # leg
akt_leg.append(query.value(2)) # set
akt_leg.append(query.value(3)) # winner
legek.append(akt_leg)
# Egy listában meg van az adott torna összes lejátszott leg-je
# Kinullázzuk az eredményeket, mert a lekérdezés az összeset tudja lekérni, nem csak a legfrissebbet!!!
for x in range(self.csoportok_szama):
for y in range(self.sorok_szama):
for z in range(self.sorok_szama):
self.eredmenyek[x][y][z]._set_leg1(0)
self.eredmenyek[x][y][z]._set_leg2(0)
# Először összegezzük mindenhol a nyert legeket
for k in legek:
for x in range(self.csoportok_szama):
for y in range(self.sorok_szama):
for z in range(self.sorok_szama):
if self.eredmenyek[x][y][z]._get_p1_id(
) == k[1] and self.eredmenyek[x][y][z]._get_p2_id(
) == k[2]:
if self.eredmenyek[x][y][z]._get_p1_id() == k[5]:
self.eredmenyek[x][y][z]._set_leg1(
self.eredmenyek[x][y][z]._get_leg1() + 1)
self.eredmenyek[x][y][z].change_leg1_number()
else:
self.eredmenyek[x][y][z]._set_leg2(
self.eredmenyek[x][y][z]._get_leg2() + 1)
self.eredmenyek[x][y][z].change_leg2_number()
# ellenfél szempontjából:
if self.eredmenyek[x][y][z]._get_p1_id(
) == k[2] and self.eredmenyek[x][y][z]._get_p2_id(
) == k[1]:
if self.eredmenyek[x][y][z]._get_p1_id() == k[5]:
self.eredmenyek[x][y][z]._set_leg1(
self.eredmenyek[x][y][z]._get_leg1() + 1)
self.eredmenyek[x][y][z].change_leg1_number()
else:
self.eredmenyek[x][y][z]._set_leg2(
self.eredmenyek[x][y][z]._get_leg2() + 1)
self.eredmenyek[x][y][z].change_leg2_number()
# Megnézzük, hogy valaki megnyerte-e. Ha igen akkor a nyerésért/vereségért járó pontot rögzítjük
for x in range(self.csoportok_szama):
for y in range(self.sorok_szama):
for z in range(self.sorok_szama):
if self.eredmenyek[x][y][z]._get_leg1(
) == self.nyereshez_kell:
self.eredmenyek[x][y][z]._set_pontszam(
int(self.pont_gyozelem))
self.eredmenyek[x][y][z].update_osszes_pont()
if self.eredmenyek[x][y][z]._get_leg2(
) == self.nyereshez_kell:
self.eredmenyek[x][y][z]._set_pontszam(
int(self.pont_vereseg))
self.eredmenyek[x][y][z].update_osszes_pont()
# helyezések
helyezesek = []
for cs in range(self.csoportok_szama):
helyezes_oszlop = []
for oszlop in range(self.sorok_szama):
# self.szum_eredmenyek[self._csoport_number][4][self._csoport_sor].
self.szum_eredmenyek[cs][4][oszlop]._set_ertek(3)
class QDisasmStatusBar(QFrame):
"""
Status and control bar for disassembly views
"""
def __init__(self, disasm_view, parent=None):
super().__init__(parent)
self.disasm_view = disasm_view
# widgets
self._nav_toolbar: Optional[NavToolbar] = None
self._function_label: QLabel = None
self._options_menu: DisasmOptionsMenu = None
self._view_combo: QComboBox = None
# information
self._function = None
self._init_menu()
self._init_widgets()
@property
def function(self):
return self._function
@function.setter
def function(self, f):
self._function = f
self._update_function_address()
@property
def function_address(self):
if self._function is None:
return None
return self._function.addr
#
# Initialization
#
def _init_widgets(self):
self._nav_toolbar = NavToolbar(
self.disasm_view.jump_history, self.disasm_view.jump_back,
self.disasm_view.jump_forward,
self.disasm_view.jump_to_history_position, True, self)
# current function
self._function_label = QLabel()
self._view_combo = QComboBox(self)
self._view_combo.addItem("Linear Disassembly", QLinearDisassembly)
self._view_combo.addItem("Graph Disassembly", QDisassemblyGraph)
self._view_combo.activated.connect(self._view_combo_changed)
self.disasm_view.view_visibility_changed.connect(
self._update_view_combo)
self._update_view_combo()
self._disasm_level_combo = QComboBox(self)
self._disasm_level_combo.addItem("Machine Code",
DisassemblyLevel.MachineCode)
self._disasm_level_combo.addItem("Lifter IR",
DisassemblyLevel.LifterIR)
self._disasm_level_combo.addItem("AIL", DisassemblyLevel.AIL)
self._disasm_level_combo.activated.connect(
self._disasm_level_combo_changed)
self.disasm_view.disassembly_level_changed.connect(
self._update_disasm_level_combo)
self._update_disasm_level_combo()
# options button
option_btn = QPushButton()
option_btn.setText('Options')
option_btn.setMenu(self._options_menu.qmenu())
# Save image button
saveimage_btn = QPushButton()
saveimage_btn.setText('Save image...')
saveimage_btn.clicked.connect(self._on_saveimage_btn_clicked)
layout = QHBoxLayout()
layout.setContentsMargins(2, 2, 2, 2)
layout.addWidget(self._nav_toolbar.qtoolbar())
layout.addWidget(self._function_label)
layout.addStretch(0)
layout.addWidget(saveimage_btn)
layout.addWidget(self._view_combo)
layout.addWidget(self._disasm_level_combo)
layout.addWidget(option_btn)
layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(layout)
def _init_menu(self):
self._options_menu = DisasmOptionsMenu(self.disasm_view)
#
# Private methods
#
def _view_combo_changed(self, index: int):
{
QLinearDisassembly: self.disasm_view.display_linear_viewer,
QDisassemblyGraph: self.disasm_view.display_disasm_graph
}[self._view_combo.itemData(index)]()
def _update_view_combo(self):
graph_type = type(self.disasm_view.current_graph)
index = self._view_combo.findData(graph_type)
self._view_combo.setCurrentIndex(index)
def _disasm_level_combo_changed(self, index: int):
new_level = self._disasm_level_combo.itemData(index)
self.disasm_view.set_disassembly_level(new_level)
def _update_disasm_level_combo(self):
new_level = self.disasm_view.disassembly_level
index = self._disasm_level_combo.findData(new_level)
self._disasm_level_combo.setCurrentIndex(index)
def _update_function_address(self):
if self.function_address is not None:
self._function_label.setText("Function %x" % self.function_address)
def _on_saveimage_btn_clicked(self):
filename, folder = QFileDialog.getSaveFileName(
self, 'Save image...', '', 'PNG Files (*.png);;Bitmaps (*.bmp)')
if not filename or not folder:
return
self.disasm_view.save_image_to(os.path.join(folder, filename))
class Window(QWidget):
def __init__(self):
super(Window, self).__init__()
self.renderArea = RenderArea()
self.shapeComboBox = QComboBox()
self.shapeComboBox.addItem("Polygon", RenderArea.Polygon)
self.shapeComboBox.addItem("Rectangle", RenderArea.Rect)
self.shapeComboBox.addItem("Rounded Rectangle", RenderArea.RoundedRect)
self.shapeComboBox.addItem("Ellipse", RenderArea.Ellipse)
self.shapeComboBox.addItem("Pie", RenderArea.Pie)
self.shapeComboBox.addItem("Chord", RenderArea.Chord)
self.shapeComboBox.addItem("Path", RenderArea.Path)
self.shapeComboBox.addItem("Line", RenderArea.Line)
self.shapeComboBox.addItem("Polyline", RenderArea.Polyline)
self.shapeComboBox.addItem("Arc", RenderArea.Arc)
self.shapeComboBox.addItem("Points", RenderArea.Points)
self.shapeComboBox.addItem("Text", RenderArea.Text)
self.shapeComboBox.addItem("Pixmap", RenderArea.Pixmap)
shapeLabel = QLabel("&Shape:")
shapeLabel.setBuddy(self.shapeComboBox)
self.penWidthSpinBox = QSpinBox()
self.penWidthSpinBox.setRange(0, 20)
self.penWidthSpinBox.setSpecialValueText("0 (cosmetic pen)")
penWidthLabel = QLabel("Pen &Width:")
penWidthLabel.setBuddy(self.penWidthSpinBox)
self.penStyleComboBox = QComboBox()
self.penStyleComboBox.addItem("Solid", Qt.SolidLine)
self.penStyleComboBox.addItem("Dash", Qt.DashLine)
self.penStyleComboBox.addItem("Dot", Qt.DotLine)
self.penStyleComboBox.addItem("Dash Dot", Qt.DashDotLine)
self.penStyleComboBox.addItem("Dash Dot Dot", Qt.DashDotDotLine)
self.penStyleComboBox.addItem("None", Qt.NoPen)
penStyleLabel = QLabel("&Pen Style:")
penStyleLabel.setBuddy(self.penStyleComboBox)
self.penCapComboBox = QComboBox()
self.penCapComboBox.addItem("Flat", Qt.FlatCap)
self.penCapComboBox.addItem("Square", Qt.SquareCap)
self.penCapComboBox.addItem("Round", Qt.RoundCap)
penCapLabel = QLabel("Pen &Cap:")
penCapLabel.setBuddy(self.penCapComboBox)
self.penJoinComboBox = QComboBox()
self.penJoinComboBox.addItem("Miter", Qt.MiterJoin)
self.penJoinComboBox.addItem("Bevel", Qt.BevelJoin)
self.penJoinComboBox.addItem("Round", Qt.RoundJoin)
penJoinLabel = QLabel("Pen &Join:")
penJoinLabel.setBuddy(self.penJoinComboBox)
self.brushStyleComboBox = QComboBox()
self.brushStyleComboBox.addItem("Linear Gradient",
Qt.LinearGradientPattern)
self.brushStyleComboBox.addItem("Radial Gradient",
Qt.RadialGradientPattern)
self.brushStyleComboBox.addItem("Conical Gradient",
Qt.ConicalGradientPattern)
self.brushStyleComboBox.addItem("Texture", Qt.TexturePattern)
self.brushStyleComboBox.addItem("Solid", Qt.SolidPattern)
self.brushStyleComboBox.addItem("Horizontal", Qt.HorPattern)
self.brushStyleComboBox.addItem("Vertical", Qt.VerPattern)
self.brushStyleComboBox.addItem("Cross", Qt.CrossPattern)
self.brushStyleComboBox.addItem("Backward Diagonal", Qt.BDiagPattern)
self.brushStyleComboBox.addItem("Forward Diagonal", Qt.FDiagPattern)
self.brushStyleComboBox.addItem("Diagonal Cross", Qt.DiagCrossPattern)
self.brushStyleComboBox.addItem("Dense 1", Qt.Dense1Pattern)
self.brushStyleComboBox.addItem("Dense 2", Qt.Dense2Pattern)
self.brushStyleComboBox.addItem("Dense 3", Qt.Dense3Pattern)
self.brushStyleComboBox.addItem("Dense 4", Qt.Dense4Pattern)
self.brushStyleComboBox.addItem("Dense 5", Qt.Dense5Pattern)
self.brushStyleComboBox.addItem("Dense 6", Qt.Dense6Pattern)
self.brushStyleComboBox.addItem("Dense 7", Qt.Dense7Pattern)
self.brushStyleComboBox.addItem("None", Qt.NoBrush)
brushStyleLabel = QLabel("&Brush Style:")
brushStyleLabel.setBuddy(self.brushStyleComboBox)
otherOptionsLabel = QLabel("Other Options:")
self.antialiasingCheckBox = QCheckBox("&Antialiasing")
self.transformationsCheckBox = QCheckBox("&Transformations")
self.shapeComboBox.activated.connect(self.shapeChanged)
self.penWidthSpinBox.valueChanged.connect(self.penChanged)
self.penStyleComboBox.activated.connect(self.penChanged)
self.penCapComboBox.activated.connect(self.penChanged)
self.penJoinComboBox.activated.connect(self.penChanged)
self.brushStyleComboBox.activated.connect(self.brushChanged)
self.antialiasingCheckBox.toggled.connect(
self.renderArea.setAntialiased)
self.transformationsCheckBox.toggled.connect(
self.renderArea.setTransformed)
mainLayout = QGridLayout()
mainLayout.setColumnStretch(0, 1)
mainLayout.setColumnStretch(3, 1)
mainLayout.addWidget(self.renderArea, 0, 0, 1, 4)
mainLayout.setRowMinimumHeight(1, 6)
mainLayout.addWidget(shapeLabel, 2, 1, Qt.AlignRight)
mainLayout.addWidget(self.shapeComboBox, 2, 2)
mainLayout.addWidget(penWidthLabel, 3, 1, Qt.AlignRight)
mainLayout.addWidget(self.penWidthSpinBox, 3, 2)
mainLayout.addWidget(penStyleLabel, 4, 1, Qt.AlignRight)
mainLayout.addWidget(self.penStyleComboBox, 4, 2)
mainLayout.addWidget(penCapLabel, 5, 1, Qt.AlignRight)
mainLayout.addWidget(self.penCapComboBox, 5, 2)
mainLayout.addWidget(penJoinLabel, 6, 1, Qt.AlignRight)
mainLayout.addWidget(self.penJoinComboBox, 6, 2)
mainLayout.addWidget(brushStyleLabel, 7, 1, Qt.AlignRight)
mainLayout.addWidget(self.brushStyleComboBox, 7, 2)
mainLayout.setRowMinimumHeight(8, 6)
mainLayout.addWidget(otherOptionsLabel, 9, 1, Qt.AlignRight)
mainLayout.addWidget(self.antialiasingCheckBox, 9, 2)
mainLayout.addWidget(self.transformationsCheckBox, 10, 2)
self.setLayout(mainLayout)
self.shapeChanged()
self.penChanged()
self.brushChanged()
self.antialiasingCheckBox.setChecked(True)
self.setWindowTitle("Basic Drawing")
def shapeChanged(self):
shape = self.shapeComboBox.itemData(self.shapeComboBox.currentIndex(),
IdRole)
self.renderArea.setShape(shape)
def penChanged(self):
width = self.penWidthSpinBox.value()
style = Qt.PenStyle(
self.penStyleComboBox.itemData(
self.penStyleComboBox.currentIndex(), IdRole))
cap = Qt.PenCapStyle(
self.penCapComboBox.itemData(self.penCapComboBox.currentIndex(),
IdRole))
join = Qt.PenJoinStyle(
self.penJoinComboBox.itemData(self.penJoinComboBox.currentIndex(),
IdRole))
self.renderArea.setPen(QPen(Qt.blue, width, style, cap, join))
def brushChanged(self):
style = Qt.BrushStyle(
self.brushStyleComboBox.itemData(
self.brushStyleComboBox.currentIndex(), IdRole))
if style == Qt.LinearGradientPattern:
linearGradient = QLinearGradient(0, 0, 100, 100)
linearGradient.setColorAt(0.0, Qt.white)
linearGradient.setColorAt(0.2, Qt.green)
linearGradient.setColorAt(1.0, Qt.black)
self.renderArea.setBrush(QBrush(linearGradient))
elif style == Qt.RadialGradientPattern:
radialGradient = QRadialGradient(50, 50, 50, 70, 70)
radialGradient.setColorAt(0.0, Qt.white)
radialGradient.setColorAt(0.2, Qt.green)
radialGradient.setColorAt(1.0, Qt.black)
self.renderArea.setBrush(QBrush(radialGradient))
elif style == Qt.ConicalGradientPattern:
conicalGradient = QConicalGradient(50, 50, 150)
conicalGradient.setColorAt(0.0, Qt.white)
conicalGradient.setColorAt(0.2, Qt.green)
conicalGradient.setColorAt(1.0, Qt.black)
self.renderArea.setBrush(QBrush(conicalGradient))
elif style == Qt.TexturePattern:
self.renderArea.setBrush(QBrush(QPixmap(':/images/brick.png')))
else:
self.renderArea.setBrush(QBrush(Qt.green, style))
class SelectMatchWindow(QDialog):
def __init__(self, parent=None):
super(SelectMatchWindow, self).__init__(parent)
self.parent = parent
self.setModal(True)
self.setWindowTitle("Mérkőzés választása")
self.resize(600, 400)
self.layout = QVBoxLayout()
self.setLayout(self.layout)
self.read_config()
self.tournaments = QComboBox()
self.tournaments.setModelColumn(0)
self.tournaments.currentIndexChanged.connect(self.torna_valasztas)
self.layout.addWidget(self.tournaments)
self.merkozesek = QListWidget()
self.merkozesek.setFixedHeight(300)
self.merkozesek.setFixedWidth(500)
self.merkozesek.itemDoubleClicked.connect(self.start_game)
self.merkozesek.itemSelectionChanged.connect(self.start_game)
self.layout.addWidget(self.merkozesek)
self.buttonbox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.buttonbox.clicked.connect(self.buttonbox_click)
self.layout.addWidget(self.buttonbox)
self.load_torna()
def load_torna(self):
torna = QSqlQueryModel()
query = QSqlQuery("select * from torna_settings where aktiv=1")
torna.setQuery(query)
if torna.record(0).value(0):
for i in range(torna.rowCount()):
self.tournaments.addItem(
torna.record(i).value(1),
torna.record(i).value(0)) # a value(0) a torna_id
else:
print("Nincs aktív torna")
def torna_valasztas(self, i):
print(self.tournaments.itemData(i))
# matches = QSqlRelationalTableModel()
# matches.setTable("torna_match")
# matches.setFilter(f'a.torna_id=8889 and a.player1_id=c.player_id and a.player2_id=d.player_id and c.torna_id=a.torna_id and d.torna_id=a.torna_id and a.torna_id=b.torna_id')
# matches.setFilter(f'torna_name = "{self.tournaments.currentText()}" and torna_resztvevok.torna_id=torna_settings.torna_id and station_id = "{self.station_id}"')
# matches.setRelation(0, QSqlRelation("torna_settings", "torna_id", "torna_name"))
# matches.setRelation(2, QSqlRelation("torna_resztvevok", "player_id", "player_name"))
# matches.setRelation(3, QSqlRelation("torna_resztvevok", "player_id", "player_name"))
# matches.setRelation(7, QSqlRelation("reged_station", "id", "station_id"))
# matches.select()
# print(matches)
# self.merkozesek.clear()
# for i in range(matches.rowCount()):
# self.merkozesek.addItem(matches.record(i).value(0) + "\t" +
# str(matches.record(i).value(1)) + "\t" +
# matches.record(i).value(2) + "\t" +
# matches.record(i).value(3) + "\t" +
# matches.record(i).value(4) + "\t" +
# str(matches.record(i).value(5))+ "\t" +
# str(matches.record(i).value(6)))
matches = QSqlQueryModel()
# todo itt még nincs táblához kötve a lekérés
matches_query = QSqlQuery(
f'SELECT a.match_id, b.torna_name, c.player_name as nev1, \
d.player_name as nev2, a.variant, a.sets, a.legsperset FROM `torna_match` a, torna_settings b, torna_resztvevok c, \
torna_resztvevok d WHERE a.torna_id={self.tournaments.itemData(i)} and a.player1_id=c.player_id and a.player2_id=d.player_id \
and c.torna_id=a.torna_id and d.torna_id=a.torna_id and a.torna_id=b.torna_id and a.match_status<2'
)
matches.setQuery(matches_query)
self.merkozesek.clear()
for i in range(matches.rowCount()):
self.merkozesek.addItem(
str(matches.record(i).value(0)) + "\t" +
matches.record(i).value(1) + "\t" +
matches.record(i).value(2) + "\t" +
matches.record(i).value(3) + "\t" +
matches.record(i).value(4) + "\t" +
str(matches.record(i).value(5)) + "\t" +
str(matches.record(i).value(6)))
def buttonbox_click(self, b):
if b.text() == "OK":
self.accept()
elif b.text() == "Cancel":
self.reject()
def read_config(self):
if os.path.exists('config.ini'):
# Van config.ini, ki kell értékelni
config.read('config.ini')
self.station_id = config['DEFAULT'].get('station id')
self.secret = config['DEFAULT'].get('secret key')
# todo módosítani kell a torna_match táblát, hogy tartalmazza a tabla mellett a hozzá tartozó secret-et is
else:
# Nincs config.ini, alapértékekkel inicializálni
msg = QMessageBox(self)
msg.setStyleSheet("fonz-size: 20px")
msg.setWindowTitle("Hiányzó beállítás file!")
msg.setText(
'<html style="font-size: 14px; color: red">Nem tudtam beolvasni a konfigurációt!<br></html>'
+
'<html style="font-size: 16px">Kérem módosítsa a beállításokat!</html>'
)
msg.exec_()
sys.exit(1)
def start_game(self):
para = self.merkozesek.currentItem().text().rsplit("\t")
p1_model = QSqlQueryModel()
p1_query = QSqlQuery(
f"select player_id from torna_resztvevok where player_name='{para[2]}'"
)
p1_model.setQuery(p1_query)
p2_model = QSqlQueryModel()
p2_query = QSqlQuery(
f"select player_id from torna_resztvevok where player_name='{para[3]}'"
)
p2_model.setQuery(p2_query)
params = []
params.append(para[2])
params.append(para[3])
params.append(int(para[0]))
self.match_id = int(para[0])
params.append(int(p1_model.record(0).value(0)))
params.append(int(p2_model.record(0).value(0)))
params.append(para[4])
params.append(int(para[6]))
params.append(int(para[5]))
params.append(0) # hc1
params.append(0) # hc2
params.append(0) #bets_of...
self.parent.new_game_window.params = params
self.parent.new_game_window.refresh()
def accept(self):
query = QSqlQuery(
f"update torna_match set match_status=1 where match_id={self.match_id}"
)
query.exec_()
#self.match_id
super().accept()
def reject(self):
self.parent.new_game_window.close()
super().reject()
class TornaSettingsDialog(QDialog):
def __init__(self, parent=None, torna_id=None):
super(TornaSettingsDialog, self).__init__(parent)
self.parent = parent
self.setModal(True)
self.setWindowTitle("Verseny beállítások")
self.torna_id = torna_id
self.main_layout = QVBoxLayout()
self.setLayout(self.main_layout)
if self.torna_id is not None:
self.create_torna_selection()
self.set_layouts()
self.add_variables()
self.alapertekek()
self.add_buttonbox()
def set_layouts(self):
self.tartalom_layout = QHBoxLayout()
self.main_layout.addLayout(self.tartalom_layout)
self.layout = QVBoxLayout()
self.gomb_layout = QVBoxLayout()
self.tartalom_layout.addLayout(self.layout)
self.tartalom_layout.addLayout(self.gomb_layout)
def add_variables(self):
self.layout.addWidget(QLabel("A verseny megnevezése:"))
self.torna_name = QLineEdit()
self.torna_name.setPlaceholderText("A verseny megnevezése")
self.layout.addWidget(self.torna_name)
self.layout.addWidget(QLabel("Legyen csoportkör?"))
self.is_roundrobin = QCheckBox()
self.is_roundrobin.stateChanged.connect(self.roundrobin_changed)
self.layout.addWidget(self.is_roundrobin)
self.layout.addWidget(QLabel("Csoportok száma:"))
self.csoport_number = CustomSpinBox(1, 16)
self.layout.addWidget(self.csoport_number)
self.layout.addWidget(QLabel("Játékosok száma csoportonként:"))
self.jatekos_per_csoport = CustomSpinBox(3, 8)
self.layout.addWidget(self.jatekos_per_csoport)
self.layout.addWidget(QLabel("Játéknem:"))
self.variant = CustomSpinBox(301, 1001)
self.layout.addWidget(self.variant)
self.layout.addWidget(QLabel("Set-ek?:"))
self.is_sets = QCheckBox()
self.is_sets.stateChanged.connect(self.is_sets_changed)
self.layout.addWidget(self.is_sets)
self.layout.addWidget(QLabel("Set-ek száma:"))
self.sets_number = CustomSpinBox(1, 8)
self.sets_number.setDisabled(True)
self.layout.addWidget(self.sets_number)
self.layout.addWidget(QLabel("Leg-ek száma:"))
self.legs_number = CustomSpinBox(2, 30)
self.layout.addWidget(self.legs_number)
self.layout.addWidget(QLabel("Best of..."))
self.is_best = QCheckBox()
self.layout.addWidget(self.is_best)
self.layout.addWidget(QLabel("Döntetlen"))
self.is_draw = QCheckBox()
self.is_draw.stateChanged.connect(self.is_draw_changed)
self.layout.addWidget(self.is_draw)
self.layout.addWidget(QLabel("Pont(Győzelem):"))
self.pont_win = CustomSpinBox(2, 5)
self.layout.addWidget(self.pont_win)
self.layout.addWidget(QLabel("Pont(Döntetlen):"))
self.pont_draw = CustomSpinBox(1, 3)
self.pont_draw.setDisabled(True)
self.layout.addWidget(self.pont_draw)
self.layout.addWidget(QLabel("Pont(Vereség):"))
self.pont_lost = CustomSpinBox(0, 2)
self.layout.addWidget(self.pont_lost)
self.layout.addWidget(QLabel("Főág"))
self.is_single_elim = QCheckBox()
self.is_single_elim.stateChanged.connect(self.is_single_changed)
self.layout.addWidget(self.is_single_elim)
self.layout.addWidget(QLabel("Főág száma:"))
self.num_single = CustomSpinBox(4, 128)
self.num_single.setDisabled(True)
self.layout.addWidget(self.num_single)
self.layout.addWidget(QLabel("Leg-ek száma a főágon:"))
self.leg_num_single = CustomSpinBox(3, 20)
self.leg_num_single.setDisabled(True)
self.layout.addWidget(self.leg_num_single)
self.layout.addWidget(QLabel("Leg-ek száma az elődöntőben:"))
self.leg_num_semifinal = CustomSpinBox(4, 20)
self.leg_num_semifinal.setDisabled(True)
self.layout.addWidget(self.leg_num_semifinal)
self.layout.addWidget(QLabel("Leg-ek száma a döntőben:"))
self.leg_num_final = CustomSpinBox(5, 20)
self.leg_num_final.setDisabled(True)
self.layout.addWidget(self.leg_num_final)
self.layout.addWidget(QLabel("3. hely kijátszva"))
self.is_3place = QCheckBox()
self.is_3place.stateChanged.connect(self.is_3place_changed)
self.is_3place.setDisabled(True)
self.layout.addWidget(self.is_3place)
self.layout.addWidget(QLabel("Leg-ek száma a 3. helyért:"))
self.leg_num_3place = CustomSpinBox(4, 20)
self.leg_num_3place.setDisabled(True)
self.layout.addWidget(self.leg_num_3place)
def create_torna_selection(self):
self.tournaments = QComboBox()
self.tournaments.setModelColumn(0)
self.tournaments.currentIndexChanged.connect(self.torna_valasztas)
self.main_layout.addWidget(self.tournaments)
self.load_torna()
def load_torna(self):
torna = QSqlQueryModel()
query = QSqlQuery("select * from torna_settings where aktiv=2")
torna.setQuery(query)
if torna.record(0).value(0):
for i in range(torna.rowCount()):
self.tournaments.addItem(
torna.record(i).value(1),
torna.record(i).value(0)) # a value(0) a torna_id
else:
print("Nincs aktív torna")
def torna_valasztas(self, i):
self.torna_id = self.tournaments.itemData(i)
self.alapertekek()
def alapertekek(self):
if not self.torna_id:
self.torna_name.clear()
self.is_roundrobin.setChecked(True)
self.csoport_number.setValue(1)
self.jatekos_per_csoport.setValue(4)
self.variant.setValue(501)
self.is_sets.setChecked(False)
self.sets_number.setValue(1)
self.legs_number.setValue(2)
self.is_best.setChecked(False)
self.is_draw.setChecked(False)
self.pont_win.setValue(2)
self.pont_draw.setValue(1)
self.pont_lost.setValue(0)
self.is_single_elim.setChecked(False)
self.num_single.setValue(8)
self.leg_num_single.setValue(3)
self.leg_num_semifinal.setValue(4)
self.leg_num_final.setValue(5)
self.is_3place.setChecked(False)
self.leg_num_3place.setValue(4)
else:
model = QSqlTableModel(db=db)
model.setTable("torna_settings")
model.setFilter(f"torna_id={self.torna_id}")
model.select()
# print(model.record(0))
self.torna_name.setText(model.record(0).value(1))
self.is_roundrobin.setChecked(model.record(0).value(2))
self.csoport_number.setValue(model.record(0).value(3))
self.jatekos_per_csoport.setValue(model.record(0).value(4))
self.variant.setValue(int(model.record(0).value(5)))
self.is_sets.setChecked(model.record(0).value(6))
self.sets_number.setValue(model.record(0).value(7))
self.legs_number.setValue(model.record(0).value(8))
self.is_best.setChecked(model.record(0).value(9))
self.is_draw.setChecked(model.record(0).value(10))
self.pont_win.setValue(model.record(0).value(11))
self.pont_draw.setValue(model.record(0).value(12))
self.pont_lost.setValue(model.record(0).value(13))
self.is_single_elim.setChecked(model.record(0).value(14))
self.num_single.setValue(model.record(0).value(15))
self.leg_num_single.setValue(model.record(0).value(17))
self.leg_num_semifinal.setValue(model.record(0).value(18))
self.leg_num_final.setValue(model.record(0).value(20))
self.is_3place.setChecked(model.record(0).value(16))
self.leg_num_3place.setValue(model.record(0).value(19))
def add_buttonbox(self):
self.buttonbox = QDialogButtonBox()
self.buttonbox.setOrientation(Qt.Vertical)
self.buttonbox.addButton("Mentés", QDialogButtonBox.ActionRole)
self.buttonbox.addButton("Alaphelyzet", QDialogButtonBox.ActionRole)
# self.gomb_members = QPushButton("Résztvevők")
# self.gomb_members.setDisabled(True)
# self.buttonbox.addButton(self.gomb_members, QDialogButtonBox.ActionRole)
# self.gomb_tabella = QPushButton("Tabella")
# self.gomb_tabella.setDisabled(True)
# self.buttonbox.addButton(self.gomb_tabella, QDialogButtonBox.ActionRole)
self.buttonbox.addButton("Mégsem", QDialogButtonBox.ActionRole)
self.buttonbox.clicked.connect(self.buttonbox_click)
self.gomb_layout.addWidget(self.buttonbox)
def roundrobin_changed(self, state):
if state == Qt.Checked:
self.csoport_number.setDisabled(False)
self.jatekos_per_csoport.setDisabled(False)
else:
self.csoport_number.setDisabled(True)
self.jatekos_per_csoport.setDisabled(True)
def is_sets_changed(self, state):
if state == Qt.Checked:
self.sets_number.setDisabled(False)
else:
self.sets_number.setDisabled(True)
def is_draw_changed(self, state):
if state == Qt.Checked:
self.pont_draw.setDisabled(False)
else:
self.pont_draw.setDisabled(True)
def is_single_changed(self, state):
# a főághoz kapcsolódó paraméterek tiltása/engedélyezése
if state == Qt.Checked:
self.num_single.setDisabled(False)
self.is_3place.setDisabled(False)
self.leg_num_single.setDisabled(False)
self.leg_num_semifinal.setDisabled(False)
if self.is_3place.isChecked():
self.leg_num_3place.setDisabled(False)
else:
self.leg_num_3place.setDisabled(True)
self.leg_num_final.setDisabled(False)
else:
self.num_single.setDisabled(True)
self.is_3place.setDisabled(True)
self.leg_num_single.setDisabled(True)
self.leg_num_semifinal.setDisabled(True)
self.leg_num_3place.setDisabled(True)
self.leg_num_final.setDisabled(True)
def is_3place_changed(self, state):
if state == Qt.Checked:
self.leg_num_3place.setDisabled(False)
else:
self.leg_num_3place.setDisabled(True)
def buttonbox_click(self, b):
if b.text() == "Mentés":
self.save()
elif b.text() == "Alaphelyzet":
self.alapertekek()
# elif b.text() == "Résztvevők":
# self.members()
# elif b.text() == "Tabella":
# self.tabella()
elif b.text() == "Mégsem":
self.reject()
else:
pass
def save(self):
if not self.torna_id:
self.insert_torna_settings()
else:
self.update_torna_settings()
self.close()
def insert_torna_settings(self):
van_ilyen_nev = False
if len(self.torna_name.text()) != 0:
torna_id_model = QSqlQueryModel()
query = QSqlQuery(
"select torna_id, torna_name from torna_settings", db=db)
torna_id_model.setQuery(query)
for i in range(torna_id_model.rowCount()):
if torna_id_model.record(i).value(1) == self.torna_name.text():
msg = QMessageBox(self)
msg.setStyleSheet("fonz-size: 20px")
msg.setWindowTitle("Név ütközés!")
msg.setText(
'<html style="font-size: 14px; color: red">Már van ilyen nevű verseny!<br></html>'
+
'<html style="font-size: 16px">Kérem adjon a versenynek egyedi nevet!</html>'
)
msg.exec_()
van_ilyen_nev = True
if not van_ilyen_nev:
torna_settings_model = QSqlTableModel(
db=db
) # !!!!!!! Ha több db van, akkor itt konkrétan meg kell adni
torna_settings_model.setTable("torna_settings")
record = torna_settings_model.record()
record.setValue(1, self.torna_name.text())
if self.is_roundrobin.isChecked():
record.setValue(2, 1)
else:
record.setValue(2, 0)
record.setValue(3, self.csoport_number.value())
record.setValue(4, self.jatekos_per_csoport.value())
record.setValue(5, self.variant.value())
if self.is_sets.isChecked():
record.setValue(6, 1)
else:
record.setValue(6, 0)
record.setValue(7, self.sets_number.value())
record.setValue(8, self.legs_number.value())
# print(record.value(2))
if self.is_best.isChecked():
record.setValue(9, 1)
else:
record.setValue(9, 0)
if self.is_draw.isChecked():
record.setValue(10, 1)
else:
record.setValue(10, 0)
record.setValue(11, self.pont_win.value())
record.setValue(12, self.pont_draw.value())
record.setValue(13, self.pont_lost.value())
if self.is_single_elim.isChecked():
record.setValue(14, 1)
else:
record.setValue(14, 0)
record.setValue(15, self.num_single.value())
if self.is_3place.isChecked():
record.setValue(16, 1)
else:
record.setValue(16, 0)
record.setValue(17, self.leg_num_single.value())
record.setValue(18, self.leg_num_semifinal.value())
record.setValue(19, self.leg_num_3place.value())
record.setValue(20, self.leg_num_final.value())
record.setValue(21, 2)
# aktiv flag: 0: vége, 1: folyamatban, 2: szerkesztés alatt
# print(record)
if torna_settings_model.insertRecord(-1, record):
torna_settings_model.submitAll()
else:
db.rollback()
torna_id_model2 = QSqlQueryModel()
query2 = QSqlQuery(
f"select torna_id from torna_settings where torna_name='{self.torna_name.text()}'",
db=db)
torna_id_model2.setQuery(query2)
self.torna_id = int(torna_id_model2.record(0).value(0))
self.gomb_members.setDisabled(False)
else:
msg = QMessageBox(self)
msg.setStyleSheet("fonz-size: 20px")
msg.setWindowTitle("Hiányzik a verseny neve!")
msg.setText(
'<html style="font-size: 14px; color: red">A létrehozott versenynek kell egy elnevezés!<br></html>'
+
'<html style="font-size: 16px">Kérem adja meg a verseny nevét!</html>'
)
msg.exec_()
def update_torna_settings(self):
torna_settings_model = QSqlTableModel(db=db)
torna_settings_model.setTable("torna_settings")
record = torna_settings_model.record()
torna_settings_model.select()
# for x in range(torna_settings_model.rowCount()):
# record.setGenerated(x, False)
record.setValue(0, self.torna_id)
record.setValue(1, self.torna_name.text())
if self.is_roundrobin.isChecked():
record.setValue(2, 1)
else:
record.setValue(2, 0)
record.setValue(3, self.csoport_number.value())
record.setValue(4, self.jatekos_per_csoport.value())
record.setValue(5, self.variant.value())
if self.is_sets.isChecked():
record.setValue(6, 1)
else:
record.setValue(6, 0)
record.setValue(7, self.sets_number.value())
record.setValue(8, self.legs_number.value())
if self.is_best.isChecked():
record.setValue(9, 1)
else:
record.setValue(9, 0)
if self.is_draw.isChecked():
record.setValue(10, 1)
else:
record.setValue(10, 0)
record.setValue(11, self.pont_win.value())
record.setValue(12, self.pont_draw.value())
record.setValue(13, self.pont_lost.value())
if self.is_single_elim.isChecked():
record.setValue(14, 1)
else:
record.setValue(14, 0)
record.setValue(15, self.num_single.value())
if self.is_3place.isChecked():
record.setValue(16, 1)
else:
record.setValue(16, 0)
record.setValue(17, self.leg_num_single.value())
record.setValue(18, self.leg_num_semifinal.value())
record.setValue(19, self.leg_num_3place.value())
record.setValue(20, self.leg_num_final.value())
record.setValue(21, 2)
for i in range(torna_settings_model.rowCount()):
if torna_settings_model.record(i).value(0) == self.torna_id:
# print(torna_settings_model.record(i).value(0), ":", i)
record_number = i
# print(record)
if torna_settings_model.setRecord(record_number, record):
torna_settings_model.submitAll()
else:
db.rollback()
# def members(self):
# # todo Itt kell a verseny résztvevőit öszerakni
# pass
#
# def tabella(self):
# # todo Itt kell a sorsolást, tabella összeállítást megcsinálni
# pass
def accept(self):
# todo Ez majd csak a bezáráshoz kell
super().accept()
def reject(self):
print("CANCEL")
super().reject()
def on_channel_threshold_changed(self, channel: str, index: int,
sender: QComboBox) -> None:
threshold = sender.itemData(index, Qt.UserRole)
self._channels[channel].set_threshold(threshold)
class AudioTest(QMainWindow):
PUSH_MODE_LABEL = "Enable push mode"
PULL_MODE_LABEL = "Enable pull mode"
SUSPEND_LABEL = "Suspend playback"
RESUME_LABEL = "Resume playback"
DurationSeconds = 1
ToneSampleRateHz = 600
DataSampleRateHz = 44100
def __init__(self):
super(AudioTest, self).__init__()
self.m_device = QAudioDeviceInfo.defaultOutputDevice()
self.m_output = None
self.initializeWindow()
self.initializeAudio()
def initializeWindow(self):
layout = QVBoxLayout()
self.m_deviceBox = QComboBox()
self.m_deviceBox.activated[int].connect(self.deviceChanged)
for deviceInfo in QAudioDeviceInfo.availableDevices(
QAudio.AudioOutput):
self.m_deviceBox.addItem(deviceInfo.deviceName(), deviceInfo)
layout.addWidget(self.m_deviceBox)
self.m_modeButton = QPushButton()
self.m_modeButton.clicked.connect(self.toggleMode)
self.m_modeButton.setText(self.PUSH_MODE_LABEL)
layout.addWidget(self.m_modeButton)
self.m_suspendResumeButton = QPushButton(
clicked=self.toggleSuspendResume)
self.m_suspendResumeButton.setText(self.SUSPEND_LABEL)
layout.addWidget(self.m_suspendResumeButton)
volumeBox = QHBoxLayout()
volumeLabel = QLabel("Volume:")
self.m_volumeSlider = QSlider(Qt.Horizontal,
minimum=0,
maximum=100,
singleStep=10)
self.m_volumeSlider.valueChanged.connect(self.volumeChanged)
volumeBox.addWidget(volumeLabel)
volumeBox.addWidget(self.m_volumeSlider)
layout.addLayout(volumeBox)
window = QWidget()
window.setLayout(layout)
self.setCentralWidget(window)
def initializeAudio(self):
self.m_pullTimer = QTimer(self)
self.m_pullTimer.timeout.connect(self.pullTimerExpired)
self.m_pullMode = True
self.m_format = QAudioFormat()
self.m_format.setSampleRate(self.DataSampleRateHz)
self.m_format.setChannelCount(1)
self.m_format.setSampleSize(16)
self.m_format.setCodec('audio/pcm')
self.m_format.setByteOrder(QAudioFormat.LittleEndian)
self.m_format.setSampleType(QAudioFormat.SignedInt)
info = QAudioDeviceInfo(QAudioDeviceInfo.defaultOutputDevice())
if not info.isFormatSupported(self.m_format):
qWarning("Default format not supported - trying to use nearest")
self.m_format = info.nearestFormat(self.m_format)
self.m_generator = Generator(self.m_format,
self.DurationSeconds * 1000000,
self.ToneSampleRateHz, self)
self.createAudioOutput()
def createAudioOutput(self):
self.m_audioOutput = QAudioOutput(self.m_device, self.m_format)
self.m_audioOutput.notify.connect(self.notified)
self.m_audioOutput.stateChanged.connect(self.handleStateChanged)
self.m_generator.start()
self.m_audioOutput.start(self.m_generator)
self.m_volumeSlider.setValue(self.m_audioOutput.volume() * 100)
def deviceChanged(self, index):
self.m_pullTimer.stop()
self.m_generator.stop()
self.m_audioOutput.stop()
self.m_device = self.m_deviceBox.itemData(index)
self.createAudioOutput()
def volumeChanged(self, value):
if self.m_audioOutput is not None:
self.m_audioOutput.setVolume(value / 100.0)
def notified(self):
qWarning(
"bytesFree = %d, elapsedUSecs = %d, processedUSecs = %d" %
(self.m_audioOutput.bytesFree(), self.m_audioOutput.elapsedUSecs(),
self.m_audioOutput.processedUSecs()))
def pullTimerExpired(self):
if self.m_audioOutput is not None and self.m_audioOutput.state(
) != QAudio.StoppedState:
chunks = self.m_audioOutput.bytesFree(
) // self.m_audioOutput.periodSize()
for _ in range(chunks):
data = self.m_generator.read(self.m_audioOutput.periodSize())
if data is None or len(
data) != self.m_audioOutput.periodSize():
break
self.m_output.write(data)
def toggleMode(self):
self.m_pullTimer.stop()
self.m_audioOutput.stop()
if self.m_pullMode:
self.m_modeButton.setText(self.PULL_MODE_LABEL)
self.m_output = self.m_audioOutput.start()
self.m_pullMode = False
self.m_pullTimer.start(20)
else:
self.m_modeButton.setText(self.PUSH_MODE_LABEL)
self.m_pullMode = True
self.m_audioOutput.start(self.m_generator)
self.m_suspendResumeButton.setText(self.SUSPEND_LABEL)
def toggleSuspendResume(self):
if self.m_audioOutput.state() == QAudio.SuspendedState:
qWarning("status: Suspended, resume()")
self.m_audioOutput.resume()
self.m_suspendResumeButton.setText(self.SUSPEND_LABEL)
elif self.m_audioOutput.state() == QAudio.ActiveState:
qWarning("status: Active, suspend()")
self.m_audioOutput.suspend()
self.m_suspendResumeButton.setText(self.RESUME_LABEL)
elif self.m_audioOutput.state() == QAudio.StoppedState:
qWarning("status: Stopped, resume()")
self.m_audioOutput.resume()
self.m_suspendResumeButton.setText(self.SUSPEND_LABEL)
elif self.m_audioOutput.state() == QAudio.IdleState:
qWarning("status: IdleState")
stateMap = {
QAudio.ActiveState: "ActiveState",
QAudio.SuspendedState: "SuspendedState",
QAudio.StoppedState: "StoppedState",
QAudio.IdleState: "IdleState"
}
def handleStateChanged(self, state):
qWarning("state = " + self.stateMap.get(state, "Unknown"))
class AudioTest(QMainWindow):
PUSH_MODE_LABEL = "Enable push mode"
PULL_MODE_LABEL = "Enable pull mode"
SUSPEND_LABEL = "Suspend playback"
RESUME_LABEL = "Resume playback"
DurationSeconds = 1
ToneSampleRateHz = 600
DataSampleRateHz = 44100
def __init__(self):
super(AudioTest, self).__init__()
self.m_device = QAudioDeviceInfo.defaultOutputDevice()
self.m_output = None
self.initializeWindow()
self.initializeAudio()
def initializeWindow(self):
layout = QVBoxLayout()
self.m_deviceBox = QComboBox()
self.m_deviceBox.activated[int].connect(self.deviceChanged)
for deviceInfo in QAudioDeviceInfo.availableDevices(QAudio.AudioOutput):
self.m_deviceBox.addItem(deviceInfo.deviceName(), deviceInfo)
layout.addWidget(self.m_deviceBox)
self.m_modeButton = QPushButton()
self.m_modeButton.clicked.connect(self.toggleMode)
self.m_modeButton.setText(self.PUSH_MODE_LABEL)
layout.addWidget(self.m_modeButton)
self.m_suspendResumeButton = QPushButton(
clicked=self.toggleSuspendResume)
self.m_suspendResumeButton.setText(self.SUSPEND_LABEL)
layout.addWidget(self.m_suspendResumeButton)
volumeBox = QHBoxLayout()
volumeLabel = QLabel("Volume:")
self.m_volumeSlider = QSlider(Qt.Horizontal, minimum=0, maximum=100,
singleStep=10)
self.m_volumeSlider.valueChanged.connect(self.volumeChanged)
volumeBox.addWidget(volumeLabel)
volumeBox.addWidget(self.m_volumeSlider)
layout.addLayout(volumeBox)
window = QWidget()
window.setLayout(layout)
self.setCentralWidget(window)
def initializeAudio(self):
self.m_pullTimer = QTimer(self)
self.m_pullTimer.timeout.connect(self.pullTimerExpired)
self.m_pullMode = True
self.m_format = QAudioFormat()
self.m_format.setSampleRate(self.DataSampleRateHz)
self.m_format.setChannelCount(1)
self.m_format.setSampleSize(16)
self.m_format.setCodec('audio/pcm')
self.m_format.setByteOrder(QAudioFormat.LittleEndian)
self.m_format.setSampleType(QAudioFormat.SignedInt)
info = QAudioDeviceInfo(QAudioDeviceInfo.defaultOutputDevice())
if not info.isFormatSupported(self.m_format):
qWarning("Default format not supported - trying to use nearest")
self.m_format = info.nearestFormat(self.m_format)
self.m_generator = Generator(self.m_format,
self.DurationSeconds * 1000000, self.ToneSampleRateHz, self)
self.createAudioOutput()
def createAudioOutput(self):
self.m_audioOutput = QAudioOutput(self.m_device, self.m_format)
self.m_audioOutput.notify.connect(self.notified)
self.m_audioOutput.stateChanged.connect(self.handleStateChanged)
self.m_generator.start()
self.m_audioOutput.start(self.m_generator)
self.m_volumeSlider.setValue(self.m_audioOutput.volume() * 100)
def deviceChanged(self, index):
self.m_pullTimer.stop()
self.m_generator.stop()
self.m_audioOutput.stop()
self.m_device = self.m_deviceBox.itemData(index)
self.createAudioOutput()
def volumeChanged(self, value):
if self.m_audioOutput is not None:
self.m_audioOutput.setVolume(value / 100.0)
def notified(self):
qWarning("bytesFree = %d, elapsedUSecs = %d, processedUSecs = %d" % (
self.m_audioOutput.bytesFree(),
self.m_audioOutput.elapsedUSecs(),
self.m_audioOutput.processedUSecs()))
def pullTimerExpired(self):
if self.m_audioOutput is not None and self.m_audioOutput.state() != QAudio.StoppedState:
chunks = self.m_audioOutput.bytesFree() // self.m_audioOutput.periodSize()
for _ in range(chunks):
data = self.m_generator.read(self.m_audioOutput.periodSize())
if data is None or len(data) != self.m_audioOutput.periodSize():
break
self.m_output.write(data)
def toggleMode(self):
self.m_pullTimer.stop()
self.m_audioOutput.stop()
if self.m_pullMode:
self.m_modeButton.setText(self.PULL_MODE_LABEL)
self.m_output = self.m_audioOutput.start()
self.m_pullMode = False
self.m_pullTimer.start(20)
else:
self.m_modeButton.setText(self.PUSH_MODE_LABEL)
self.m_pullMode = True
self.m_audioOutput.start(self.m_generator)
self.m_suspendResumeButton.setText(self.SUSPEND_LABEL)
def toggleSuspendResume(self):
if self.m_audioOutput.state() == QAudio.SuspendedState:
qWarning("status: Suspended, resume()")
self.m_audioOutput.resume()
self.m_suspendResumeButton.setText(self.SUSPEND_LABEL)
elif self.m_audioOutput.state() == QAudio.ActiveState:
qWarning("status: Active, suspend()")
self.m_audioOutput.suspend()
self.m_suspendResumeButton.setText(self.RESUME_LABEL)
elif self.m_audioOutput.state() == QAudio.StoppedState:
qWarning("status: Stopped, resume()")
self.m_audioOutput.resume()
self.m_suspendResumeButton.setText(self.SUSPEND_LABEL)
elif self.m_audioOutput.state() == QAudio.IdleState:
qWarning("status: IdleState")
stateMap = {
QAudio.ActiveState: "ActiveState",
QAudio.SuspendedState: "SuspendedState",
QAudio.StoppedState: "StoppedState",
QAudio.IdleState: "IdleState"}
def handleStateChanged(self, state):
qWarning("state = " + self.stateMap.get(state, "Unknown"))
class Window(QWidget):
def __init__(self):
super(Window, self).__init__()
self.proxyModel = SortFilterProxyModel()
self.proxyModel.setDynamicSortFilter(True)
self.sourceGroupBox = QGroupBox("Original Model")
self.proxyGroupBox = QGroupBox("Sorted/Filtered Model")
self.sourceView = QTreeView()
self.sourceView.setRootIsDecorated(False)
self.sourceView.setAlternatingRowColors(True)
self.proxyView = QTreeView()
self.proxyView.setRootIsDecorated(False)
self.proxyView.setAlternatingRowColors(True)
self.proxyView.setModel(self.proxyModel)
self.proxyView.setSortingEnabled(True)
self.sortCaseSensitivityCheckBox = QCheckBox("Case sensitive sorting")
self.filterCaseSensitivityCheckBox = QCheckBox("Case sensitive filter")
self.filterPatternLineEdit = QLineEdit()
self.filterPatternLabel = QLabel("&Filter pattern:")
self.filterPatternLabel.setBuddy(self.filterPatternLineEdit)
self.filterSyntaxComboBox = QComboBox()
self.filterSyntaxComboBox.addItem("Regular expression", QRegExp.RegExp)
self.filterSyntaxComboBox.addItem("Wildcard", QRegExp.Wildcard)
self.filterSyntaxComboBox.addItem("Fixed string", QRegExp.FixedString)
self.filterSyntaxLabel = QLabel("Filter &syntax:")
self.filterSyntaxLabel.setBuddy(self.filterSyntaxComboBox)
self.filterColumnComboBox = QComboBox()
self.filterColumnComboBox.addItem("Subject")
self.filterColumnComboBox.addItem("Sender")
self.filterColumnComboBox.addItem("Date")
self.filterColumnLabel = QLabel("Filter &column:")
self.filterColumnLabel.setBuddy(self.filterColumnComboBox)
self.filterPatternLineEdit.textChanged.connect(
self.filterRegExpChanged)
self.filterSyntaxComboBox.currentIndexChanged.connect(
self.filterRegExpChanged)
self.filterColumnComboBox.currentIndexChanged.connect(
self.filterColumnChanged)
self.filterCaseSensitivityCheckBox.toggled.connect(
self.filterRegExpChanged)
self.sortCaseSensitivityCheckBox.toggled.connect(self.sortChanged)
sourceLayout = QHBoxLayout()
sourceLayout.addWidget(self.sourceView)
self.sourceGroupBox.setLayout(sourceLayout)
proxyLayout = QGridLayout()
proxyLayout.addWidget(self.proxyView, 0, 0, 1, 3)
proxyLayout.addWidget(self.filterPatternLabel, 1, 0)
proxyLayout.addWidget(self.filterPatternLineEdit, 1, 1, 1, 2)
proxyLayout.addWidget(self.filterSyntaxLabel, 2, 0)
proxyLayout.addWidget(self.filterSyntaxComboBox, 2, 1, 1, 2)
proxyLayout.addWidget(self.filterColumnLabel, 3, 0)
proxyLayout.addWidget(self.filterColumnComboBox, 3, 1, 1, 2)
proxyLayout.addWidget(self.filterCaseSensitivityCheckBox, 4, 0, 1, 2)
proxyLayout.addWidget(self.sortCaseSensitivityCheckBox, 4, 2)
self.proxyGroupBox.setLayout(proxyLayout)
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.sourceGroupBox)
mainLayout.addWidget(self.proxyGroupBox)
self.setLayout(mainLayout)
self.setWindowTitle("Basic Sort/Filter Model")
self.resize(500, 450)
self.proxyView.sortByColumn(SENDER, Qt.AscendingOrder)
self.filterColumnComboBox.setCurrentIndex(SENDER)
self.filterPatternLineEdit.setText("Andy|Grace")
self.filterCaseSensitivityCheckBox.setChecked(True)
self.sortCaseSensitivityCheckBox.setChecked(True)
def setSourceModel(self, model):
self.proxyModel.setSourceModel(model)
self.sourceView.setModel(model)
def filterRegExpChanged(self):
syntax_nr = self.filterSyntaxComboBox.itemData(
self.filterSyntaxComboBox.currentIndex())
syntax = QRegExp.PatternSyntax(syntax_nr)
if self.filterCaseSensitivityCheckBox.isChecked():
caseSensitivity = Qt.CaseSensitive
else:
caseSensitivity = Qt.CaseInsensitive
regExp = QRegExp(self.filterPatternLineEdit.text(), caseSensitivity,
syntax)
self.proxyModel.setFilterRegExp(regExp)
def filterColumnChanged(self):
self.proxyModel.setFilterKeyColumn(
self.filterColumnComboBox.currentIndex())
def sortChanged(self):
if self.sortCaseSensitivityCheckBox.isChecked():
caseSensitivity = Qt.CaseSensitive
else:
caseSensitivity = Qt.CaseInsensitive
self.proxyModel.setSortCaseSensitivity(caseSensitivity)
class Window(QWidget):
def __init__(self):
super(Window, self).__init__()
self.renderArea = RenderArea()
self.shapeComboBox = QComboBox()
self.shapeComboBox.addItem("Polygon", RenderArea.Polygon)
self.shapeComboBox.addItem("Rectangle", RenderArea.Rect)
self.shapeComboBox.addItem("Rounded Rectangle", RenderArea.RoundedRect)
self.shapeComboBox.addItem("Ellipse", RenderArea.Ellipse)
self.shapeComboBox.addItem("Pie", RenderArea.Pie)
self.shapeComboBox.addItem("Chord", RenderArea.Chord)
self.shapeComboBox.addItem("Path", RenderArea.Path)
self.shapeComboBox.addItem("Line", RenderArea.Line)
self.shapeComboBox.addItem("Polyline", RenderArea.Polyline)
self.shapeComboBox.addItem("Arc", RenderArea.Arc)
self.shapeComboBox.addItem("Points", RenderArea.Points)
self.shapeComboBox.addItem("Text", RenderArea.Text)
self.shapeComboBox.addItem("Pixmap", RenderArea.Pixmap)
shapeLabel = QLabel("&Shape:")
shapeLabel.setBuddy(self.shapeComboBox)
self.penWidthSpinBox = QSpinBox()
self.penWidthSpinBox.setRange(0, 20)
self.penWidthSpinBox.setSpecialValueText("0 (cosmetic pen)")
penWidthLabel = QLabel("Pen &Width:")
penWidthLabel.setBuddy(self.penWidthSpinBox)
self.penStyleComboBox = QComboBox()
self.penStyleComboBox.addItem("Solid", Qt.SolidLine)
self.penStyleComboBox.addItem("Dash", Qt.DashLine)
self.penStyleComboBox.addItem("Dot", Qt.DotLine)
self.penStyleComboBox.addItem("Dash Dot", Qt.DashDotLine)
self.penStyleComboBox.addItem("Dash Dot Dot", Qt.DashDotDotLine)
self.penStyleComboBox.addItem("None", Qt.NoPen)
penStyleLabel = QLabel("&Pen Style:")
penStyleLabel.setBuddy(self.penStyleComboBox)
self.penCapComboBox = QComboBox()
self.penCapComboBox.addItem("Flat", Qt.FlatCap)
self.penCapComboBox.addItem("Square", Qt.SquareCap)
self.penCapComboBox.addItem("Round", Qt.RoundCap)
penCapLabel = QLabel("Pen &Cap:")
penCapLabel.setBuddy(self.penCapComboBox)
self.penJoinComboBox = QComboBox()
self.penJoinComboBox.addItem("Miter", Qt.MiterJoin)
self.penJoinComboBox.addItem("Bevel", Qt.BevelJoin)
self.penJoinComboBox.addItem("Round", Qt.RoundJoin)
penJoinLabel = QLabel("Pen &Join:")
penJoinLabel.setBuddy(self.penJoinComboBox)
self.brushStyleComboBox = QComboBox()
self.brushStyleComboBox.addItem("Linear Gradient",
Qt.LinearGradientPattern)
self.brushStyleComboBox.addItem("Radial Gradient",
Qt.RadialGradientPattern)
self.brushStyleComboBox.addItem("Conical Gradient",
Qt.ConicalGradientPattern)
self.brushStyleComboBox.addItem("Texture", Qt.TexturePattern)
self.brushStyleComboBox.addItem("Solid", Qt.SolidPattern)
self.brushStyleComboBox.addItem("Horizontal", Qt.HorPattern)
self.brushStyleComboBox.addItem("Vertical", Qt.VerPattern)
self.brushStyleComboBox.addItem("Cross", Qt.CrossPattern)
self.brushStyleComboBox.addItem("Backward Diagonal", Qt.BDiagPattern)
self.brushStyleComboBox.addItem("Forward Diagonal", Qt.FDiagPattern)
self.brushStyleComboBox.addItem("Diagonal Cross", Qt.DiagCrossPattern)
self.brushStyleComboBox.addItem("Dense 1", Qt.Dense1Pattern)
self.brushStyleComboBox.addItem("Dense 2", Qt.Dense2Pattern)
self.brushStyleComboBox.addItem("Dense 3", Qt.Dense3Pattern)
self.brushStyleComboBox.addItem("Dense 4", Qt.Dense4Pattern)
self.brushStyleComboBox.addItem("Dense 5", Qt.Dense5Pattern)
self.brushStyleComboBox.addItem("Dense 6", Qt.Dense6Pattern)
self.brushStyleComboBox.addItem("Dense 7", Qt.Dense7Pattern)
self.brushStyleComboBox.addItem("None", Qt.NoBrush)
brushStyleLabel = QLabel("&Brush Style:")
brushStyleLabel.setBuddy(self.brushStyleComboBox)
otherOptionsLabel = QLabel("Other Options:")
self.antialiasingCheckBox = QCheckBox("&Antialiasing")
self.transformationsCheckBox = QCheckBox("&Transformations")
self.shapeComboBox.activated.connect(self.shapeChanged)
self.penWidthSpinBox.valueChanged.connect(self.penChanged)
self.penStyleComboBox.activated.connect(self.penChanged)
self.penCapComboBox.activated.connect(self.penChanged)
self.penJoinComboBox.activated.connect(self.penChanged)
self.brushStyleComboBox.activated.connect(self.brushChanged)
self.antialiasingCheckBox.toggled.connect(self.renderArea.setAntialiased)
self.transformationsCheckBox.toggled.connect(self.renderArea.setTransformed)
mainLayout = QGridLayout()
mainLayout.setColumnStretch(0, 1)
mainLayout.setColumnStretch(3, 1)
mainLayout.addWidget(self.renderArea, 0, 0, 1, 4)
mainLayout.setRowMinimumHeight(1, 6)
mainLayout.addWidget(shapeLabel, 2, 1, Qt.AlignRight)
mainLayout.addWidget(self.shapeComboBox, 2, 2)
mainLayout.addWidget(penWidthLabel, 3, 1, Qt.AlignRight)
mainLayout.addWidget(self.penWidthSpinBox, 3, 2)
mainLayout.addWidget(penStyleLabel, 4, 1, Qt.AlignRight)
mainLayout.addWidget(self.penStyleComboBox, 4, 2)
mainLayout.addWidget(penCapLabel, 5, 1, Qt.AlignRight)
mainLayout.addWidget(self.penCapComboBox, 5, 2)
mainLayout.addWidget(penJoinLabel, 6, 1, Qt.AlignRight)
mainLayout.addWidget(self.penJoinComboBox, 6, 2)
mainLayout.addWidget(brushStyleLabel, 7, 1, Qt.AlignRight)
mainLayout.addWidget(self.brushStyleComboBox, 7, 2)
mainLayout.setRowMinimumHeight(8, 6)
mainLayout.addWidget(otherOptionsLabel, 9, 1, Qt.AlignRight)
mainLayout.addWidget(self.antialiasingCheckBox, 9, 2)
mainLayout.addWidget(self.transformationsCheckBox, 10, 2)
self.setLayout(mainLayout)
self.shapeChanged()
self.penChanged()
self.brushChanged()
self.antialiasingCheckBox.setChecked(True)
self.setWindowTitle("Basic Drawing")
def shapeChanged(self):
shape = self.shapeComboBox.itemData(self.shapeComboBox.currentIndex(),
IdRole)
self.renderArea.setShape(shape)
def penChanged(self):
width = self.penWidthSpinBox.value()
style = Qt.PenStyle(self.penStyleComboBox.itemData(
self.penStyleComboBox.currentIndex(), IdRole))
cap = Qt.PenCapStyle(self.penCapComboBox.itemData(
self.penCapComboBox.currentIndex(), IdRole))
join = Qt.PenJoinStyle(self.penJoinComboBox.itemData(
self.penJoinComboBox.currentIndex(), IdRole))
self.renderArea.setPen(QPen(Qt.blue, width, style, cap, join))
def brushChanged(self):
style = Qt.BrushStyle(self.brushStyleComboBox.itemData(
self.brushStyleComboBox.currentIndex(), IdRole))
if style == Qt.LinearGradientPattern:
linearGradient = QLinearGradient(0, 0, 100, 100)
linearGradient.setColorAt(0.0, Qt.white)
linearGradient.setColorAt(0.2, Qt.green)
linearGradient.setColorAt(1.0, Qt.black)
self.renderArea.setBrush(QBrush(linearGradient))
elif style == Qt.RadialGradientPattern:
radialGradient = QRadialGradient(50, 50, 50, 70, 70)
radialGradient.setColorAt(0.0, Qt.white)
radialGradient.setColorAt(0.2, Qt.green)
radialGradient.setColorAt(1.0, Qt.black)
self.renderArea.setBrush(QBrush(radialGradient))
elif style == Qt.ConicalGradientPattern:
conicalGradient = QConicalGradient(50, 50, 150)
conicalGradient.setColorAt(0.0, Qt.white)
conicalGradient.setColorAt(0.2, Qt.green)
conicalGradient.setColorAt(1.0, Qt.black)
self.renderArea.setBrush(QBrush(conicalGradient))
elif style == Qt.TexturePattern:
self.renderArea.setBrush(QBrush(QPixmap(':/images/brick.png')))
else:
self.renderArea.setBrush(QBrush(Qt.green, style))
class Window(QDialog):
def __init__(self, parent=None):
super(Window, self).__init__(parent)
self.iconGroupBox = QGroupBox()
self.iconLabel = QLabel()
self.iconComboBox = QComboBox()
self.showIconCheckBox = QCheckBox()
self.messageGroupBox = QGroupBox()
self.typeLabel = QLabel()
self.durationLabel = QLabel()
self.durationWarningLabel = QLabel()
self.titleLabel = QLabel()
self.bodyLabel = QLabel()
self.typeComboBox = QComboBox()
self.durationSpinBox = QSpinBox()
self.titleEdit = QLineEdit()
self.bodyEdit = QTextEdit()
self.showMessageButton = QPushButton()
self.minimizeAction = QAction()
self.maximizeAction = QAction()
self.restoreAction = QAction()
self.quitAction = QAction()
self.trayIcon = QSystemTrayIcon()
self.trayIconMenu = QMenu()
self.createIconGroupBox()
self.createMessageGroupBox()
self.iconLabel.setMinimumWidth(self.durationLabel.sizeHint().width())
self.createActions()
self.createTrayIcon()
self.showMessageButton.clicked.connect(self.showMessage)
self.showIconCheckBox.toggled.connect(self.trayIcon.setVisible)
self.iconComboBox.currentIndexChanged.connect(self.setIcon)
self.trayIcon.messageClicked.connect(self.messageClicked)
self.trayIcon.activated.connect(self.iconActivated)
self.mainLayout = QVBoxLayout()
self.mainLayout.addWidget(self.iconGroupBox)
self.mainLayout.addWidget(self.messageGroupBox)
self.setLayout(self.mainLayout)
self.iconComboBox.setCurrentIndex(1)
self.trayIcon.show()
self.setWindowTitle("Systray")
self.resize(400, 300)
def setVisible(self, visible):
self.minimizeAction.setEnabled(visible)
self.maximizeAction.setEnabled(not self.isMaximized())
self.restoreAction.setEnabled(self.isMaximized() or not visible)
super().setVisible(visible)
def closeEvent(self, event):
if not event.spontaneous() or not self.isVisible():
return
if self.trayIcon.isVisible():
QMessageBox.information(self, "Systray",
"The program will keep running in the system tray. "
"To terminate the program, choose <b>Quit</b> in the context "
"menu of the system tray entry.")
self.hide()
event.ignore()
@Slot(int)
def setIcon(self, index):
icon = self.iconComboBox.itemIcon(index)
self.trayIcon.setIcon(icon)
self.setWindowIcon(icon)
self.trayIcon.setToolTip(self.iconComboBox.itemText(index))
@Slot(str)
def iconActivated(self, reason):
if reason == QSystemTrayIcon.Trigger:
pass
if reason == QSystemTrayIcon.DoubleClick:
self.iconComboBox.setCurrentIndex(
(self.iconComboBox.currentIndex() + 1) % self.iconComboBox.count()
)
if reason == QSystemTrayIcon.MiddleClick:
self.showMessage()
@Slot()
def showMessage(self):
self.showIconCheckBox.setChecked(True)
selectedIcon = self.typeComboBox.itemData(self.typeComboBox.currentIndex())
msgIcon = QSystemTrayIcon.MessageIcon(selectedIcon)
if selectedIcon == -1: # custom icon
icon = QIcon(self.iconComboBox.itemIcon(self.iconComboBox.currentIndex()))
self.trayIcon.showMessage(
self.titleEdit.text(),
self.bodyEdit.toPlainText(),
icon,
self.durationSpinBox.value() * 1000,
)
else:
self.trayIcon.showMessage(
self.titleEdit.text(),
self.bodyEdit.toPlainText(),
msgIcon,
self.durationSpinBox.value() * 1000,
)
@Slot()
def messageClicked(self):
QMessageBox.information(None, "Systray",
"Sorry, I already gave what help I could.\n"
"Maybe you should try asking a human?")
def createIconGroupBox(self):
self.iconGroupBox = QGroupBox("Tray Icon")
self.iconLabel = QLabel("Icon:")
self.iconComboBox = QComboBox()
self.iconComboBox.addItem(QIcon(":/images/bad.png"), "Bad")
self.iconComboBox.addItem(QIcon(":/images/heart.png"), "Heart")
self.iconComboBox.addItem(QIcon(":/images/trash.png"), "Trash")
self.showIconCheckBox = QCheckBox("Show icon")
self.showIconCheckBox.setChecked(True)
iconLayout = QHBoxLayout()
iconLayout.addWidget(self.iconLabel)
iconLayout.addWidget(self.iconComboBox)
iconLayout.addStretch()
iconLayout.addWidget(self.showIconCheckBox)
self.iconGroupBox.setLayout(iconLayout)
def createMessageGroupBox(self):
self.messageGroupBox = QGroupBox("Balloon Message")
self.typeLabel = QLabel("Type:")
self.typeComboBox = QComboBox()
self.typeComboBox.addItem("None", QSystemTrayIcon.NoIcon)
self.typeComboBox.addItem(
self.style().standardIcon(QStyle.SP_MessageBoxInformation),
"Information",
QSystemTrayIcon.Information,
)
self.typeComboBox.addItem(
self.style().standardIcon(QStyle.SP_MessageBoxWarning),
"Warning",
QSystemTrayIcon.Warning,
)
self.typeComboBox.addItem(
self.style().standardIcon(QStyle.SP_MessageBoxCritical),
"Critical",
QSystemTrayIcon.Critical,
)
self.typeComboBox.addItem(QIcon(), "Custom icon", -1)
self.typeComboBox.setCurrentIndex(1)
self.durationLabel = QLabel("Duration:")
self.durationSpinBox = QSpinBox()
self.durationSpinBox.setRange(5, 60)
self.durationSpinBox.setSuffix(" s")
self.durationSpinBox.setValue(15)
self.durationWarningLabel = QLabel("(some systems might ignore this hint)")
self.durationWarningLabel.setIndent(10)
self.titleLabel = QLabel("Title:")
self.titleEdit = QLineEdit("Cannot connect to network")
self.bodyLabel = QLabel("Body:")
self.bodyEdit = QTextEdit()
self.bodyEdit.setPlainText("Don't believe me. Honestly, I don't have a clue."
"\nClick this balloon for details.")
self.showMessageButton = QPushButton("Show Message")
self.showMessageButton.setDefault(True)
messageLayout = QGridLayout()
messageLayout.addWidget(self.typeLabel, 0, 0)
messageLayout.addWidget(self.typeComboBox, 0, 1, 1, 2)
messageLayout.addWidget(self.durationLabel, 1, 0)
messageLayout.addWidget(self.durationSpinBox, 1, 1)
messageLayout.addWidget(self.durationWarningLabel, 1, 2, 1, 3)
messageLayout.addWidget(self.titleLabel, 2, 0)
messageLayout.addWidget(self.titleEdit, 2, 1, 1, 4)
messageLayout.addWidget(self.bodyLabel, 3, 0)
messageLayout.addWidget(self.bodyEdit, 3, 1, 2, 4)
messageLayout.addWidget(self.showMessageButton, 5, 4)
messageLayout.setColumnStretch(3, 1)
messageLayout.setRowStretch(4, 1)
self.messageGroupBox.setLayout(messageLayout)
def createActions(self):
self.minimizeAction = QAction("Minimize", self)
self.minimizeAction.triggered.connect(self.hide)
self.maximizeAction = QAction("Maximize", self)
self.maximizeAction.triggered.connect(self.showMaximized)
self.restoreAction = QAction("Restore", self)
self.restoreAction.triggered.connect(self.showNormal)
self.quitAction = QAction("Quit", self)
self.quitAction.triggered.connect(qApp.quit)
def createTrayIcon(self):
self.trayIconMenu = QMenu(self)
self.trayIconMenu.addAction(self.minimizeAction)
self.trayIconMenu.addAction(self.maximizeAction)
self.trayIconMenu.addAction(self.restoreAction)
self.trayIconMenu.addSeparator()
self.trayIconMenu.addAction(self.quitAction)
self.trayIcon = QSystemTrayIcon(self)
self.trayIcon.setContextMenu(self.trayIconMenu)
class QBuyGroupForGroundObjectDialog(QDialog):
changed = QtCore.Signal()
def __init__(self, parent, ground_object: TheaterGroundObject,
cp: ControlPoint, game: Game, current_group_value: int):
super(QBuyGroupForGroundObjectDialog, self).__init__(parent)
self.setMinimumWidth(350)
self.ground_object = ground_object
self.cp = cp
self.game = game
self.current_group_value = current_group_value
self.setWindowTitle("Buy units @ " + self.ground_object.obj_name)
self.setWindowIcon(EVENT_ICONS["capture"])
self.buySamButton = QPushButton("Buy")
self.buyArmorButton = QPushButton("Buy")
self.buySamLayout = QGridLayout()
self.buyArmorLayout = QGridLayout()
self.amount = QSpinBox()
self.buyArmorCombo = QComboBox()
self.samCombo = QComboBox()
self.buySamBox = QGroupBox("Buy SAM site :")
self.buyArmorBox = QGroupBox("Buy defensive position :")
self.init_ui()
def init_ui(self):
faction = self.game.player_name
# Sams
possible_sams = get_faction_possible_sams_generator(faction)
for sam in possible_sams:
self.samCombo.addItem(sam.name + " [$" + str(sam.price) + "M]",
userData=sam)
self.samCombo.currentIndexChanged.connect(self.samComboChanged)
self.buySamLayout.addWidget(QLabel("Site Type :"), 0, 0, Qt.AlignLeft)
self.buySamLayout.addWidget(self.samCombo,
0,
1,
alignment=Qt.AlignRight)
self.buySamLayout.addWidget(self.buySamButton,
1,
1,
alignment=Qt.AlignRight)
stretch = QVBoxLayout()
stretch.addStretch()
self.buySamLayout.addLayout(stretch, 2, 0)
self.buySamButton.clicked.connect(self.buySam)
# Armored units
armored_units = db.find_unittype(
PinpointStrike, faction) # Todo : refactor this legacy nonsense
for unit in set(armored_units):
self.buyArmorCombo.addItem(db.unit_type_name_2(unit) + " [$" +
str(db.PRICES[unit]) + "M]",
userData=unit)
self.buyArmorCombo.currentIndexChanged.connect(self.armorComboChanged)
self.amount.setMinimum(2)
self.amount.setMaximum(8)
self.amount.setValue(2)
self.amount.valueChanged.connect(self.amountComboChanged)
self.buyArmorLayout.addWidget(QLabel("Unit type :"), 0, 0,
Qt.AlignLeft)
self.buyArmorLayout.addWidget(self.buyArmorCombo,
0,
1,
alignment=Qt.AlignRight)
self.buyArmorLayout.addWidget(QLabel("Group size :"),
1,
0,
alignment=Qt.AlignLeft)
self.buyArmorLayout.addWidget(self.amount,
1,
1,
alignment=Qt.AlignRight)
self.buyArmorLayout.addWidget(self.buyArmorButton,
2,
1,
alignment=Qt.AlignRight)
stretch2 = QVBoxLayout()
stretch2.addStretch()
self.buyArmorLayout.addLayout(stretch2, 3, 0)
self.buyArmorButton.clicked.connect(self.buyArmor)
# Do layout
self.buySamBox.setLayout(self.buySamLayout)
self.buyArmorBox.setLayout(self.buyArmorLayout)
self.mainLayout = QHBoxLayout()
self.mainLayout.addWidget(self.buySamBox)
if self.ground_object.airbase_group:
self.mainLayout.addWidget(self.buyArmorBox)
self.setLayout(self.mainLayout)
try:
self.samComboChanged(0)
self.armorComboChanged(0)
except:
pass
def samComboChanged(self, index):
self.buySamButton.setText("Buy [$" +
str(self.samCombo.itemData(index).price) +
"M] [-$" + str(self.current_group_value) +
"M]")
def armorComboChanged(self, index):
self.buyArmorButton.setText(
"Buy [$" + str(db.PRICES[self.buyArmorCombo.itemData(index)] *
self.amount.value()) + "M][-$" +
str(self.current_group_value) + "M]")
def amountComboChanged(self):
self.buyArmorButton.setText("Buy [$" + str(db.PRICES[
self.buyArmorCombo.itemData(self.buyArmorCombo.currentIndex())] *
self.amount.value()) +
"M][-$" + str(self.current_group_value) +
"M]")
def buyArmor(self):
print("Buy Armor ")
utype = self.buyArmorCombo.itemData(self.buyArmorCombo.currentIndex())
print(utype)
price = db.PRICES[utype] * self.amount.value(
) - self.current_group_value
if price > self.game.budget:
self.error_money()
self.close()
return
else:
self.game.budget -= price
# Generate Armor
group = generate_armor_group_of_type_and_size(self.game,
self.ground_object,
utype,
int(self.amount.value()))
self.ground_object.groups = [group]
GameUpdateSignal.get_instance().updateBudget(self.game)
self.changed.emit()
self.close()
def buySam(self):
sam_generator = self.samCombo.itemData(self.samCombo.currentIndex())
price = sam_generator.price - self.current_group_value
if price > self.game.budget:
self.error_money()
return
else:
self.game.budget -= price
# Generate SAM
generator = sam_generator(self.game, self.ground_object)
generator.generate()
generated_group = generator.get_generated_group()
self.ground_object.groups = [generated_group]
GameUpdateSignal.get_instance().updateBudget(self.game)
self.changed.emit()
self.close()
def error_money(self):
msg = QMessageBox()
msg.setIcon(QMessageBox.Information)
msg.setText("Not enough money to buy these units !")
msg.setWindowTitle("Not enough money")
msg.setStandardButtons(QMessageBox.Ok)
msg.setWindowFlags(Qt.WindowStaysOnTopHint)
msg.exec_()
self.close()
class CsoportTabla(QDialog):
def __init__(self, parent=None):
super(CsoportTabla, self).__init__(parent)
self.setWindowTitle("Csoportok, ágak összeállítása")
self.setMinimumHeight(650)
# self.setMinimumWidth(700)
# self.resize(800, 650)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.hatter = QVBoxLayout()
self.setLayout(self.hatter)
self.create_torna_selection()
self.hatter.addWidget(self.tournaments)
self.space = QSpacerItem(0, 0, QSizePolicy.Minimum,
QSizePolicy.Expanding)
self.hatter.addItem(self.space)
# self.create_widgets()
# self.set_layout()
def create_widgets(self):
if hasattr(self, 'resztvevok'):
self.resztvevok.load_data(self.torna_id)
else:
self.resztvevok = resztvevokLista(self.torna_id)
self.resztvevok.load_data(self.torna_id)
# GroupMemberWidget-ek
self.csoportok = []
for i in range(self.csoportok_szama): # Csoportok száma
self.csoportoszlop = []
for j in range(self.sorok_szama): # fő/csoport
self.csoportoszlop.append(GroupMemberWidget(self))
self.csoportoszlop[j]._set_csoport_number(i)
self.csoportoszlop[j]._set_csoport_sor(j)
self.csoportoszlop[j]._set_sorok_szama(self.sorok_szama)
self.csoportok.append(self.csoportoszlop)
# EredmenyWidget-ek
self.eredmenyek = []
for i in range(self.csoportok_szama):
self.csoport_eredmeny_matrix = []
for j in range(
self.sorok_szama): # ami egyenlő az oszlopok számával!!!
self.eredmeny_oszlop = []
for x in range(self.sorok_szama):
self.eredmeny_oszlop.append(EredmenyWidget(self))
self.eredmeny_oszlop[x]._set_csoport_number(i)
self.eredmeny_oszlop[x]._set_csoport_sor(x)
self.eredmeny_oszlop[x]._set_csoport_oszlop(j)
self.csoport_eredmeny_matrix.append(self.eredmeny_oszlop)
self.eredmenyek.append(self.csoport_eredmeny_matrix)
# Gombok
if hasattr(self, 'generate_button'):
pass
else:
self.generate_button = QPushButton("Tábla véglegesítése")
self.generate_button.clicked.connect(self.generate_match_records)
if hasattr(self, 'autofill_button'):
pass
else:
self.autofill_button = QPushButton("Automatikus kitöltés")
self.autofill_button.clicked.connect(self.generate_boards)
def set_layout(self):
if hasattr(self, 'main_layout'):
for i in reversed(range(self.main_layout.count())):
if self.main_layout.itemAt(i).widget() is not None:
self.main_layout.itemAt(i).widget().deleteLater()
for i in reversed(range(self.main_layout.count())):
if self.main_layout.itemAt(i).layout() is not None:
self.main_layout.itemAt(i).layout().deleteLater()
else:
self.main_layout = QHBoxLayout()
self.hatter.addLayout(self.main_layout)
groups = QWidget()
groups.setFixedWidth((self.sorok_szama * 50) + 200)
widgets_layout = QVBoxLayout()
groups.setLayout(widgets_layout)
for n in range(self.csoportok_szama): # csoportok száma
locals()['csoport_layout' + str(n)] = QGridLayout(
) # Létrehozzuk az adott sorszámú csoport layout-ját
locals()['csoport_layout' + str(n)].setContentsMargins(0, 0, 0, 0)
locals()['csoport_layout' + str(n)].setHorizontalSpacing(0)
locals()['csoport_layout' + str(n)].setVerticalSpacing(0)
widgets_layout.addLayout(locals()[
'csoport_layout' +
str(n)]) # Hozzáadjuk a a layout-ot a widget_layout-hoz
for i in range(
len(self.csoportok[n])
): # len(self.csoportok[n]) : csoporton belüli sorok száma
# Végigmegyünk a sorokon : i: sorok száma, n: csoport száma
# a layout 1. oszlopát feltöltjük a tömbben tárolt custom widget-ekkel
locals()['csoport_layout' + str(n)].addWidget(
self.csoportok[n][i], i + 1, 0)
# Itt töltjük fel az eredmény-widget-eket (tombben tárolva, mint a GroupMemberWidget-ek) eredmenyek[x, y, z] x: csoport, y: oszlop, z: sor
for x in range(
len(self.csoportok[n])
): # Ez lesz az oszlop(max = sorok száma) x: oszlop száma
locals()['csoport_layout' + str(n)].addWidget(
self.eredmenyek[n][i][x], i + 1, x + 1)
locals()['csoport_layout' + str(n)].addWidget(
QLabel("Csoport_" + str(n + 1)), 0, 0)
lista_layout = QVBoxLayout()
lista_layout.addWidget(self.autofill_button)
lista_layout.addWidget(self.resztvevok)
lista_layout.addWidget(self.generate_button)
# lista_layout.addWidget(self.clear_button)
scroll = QScrollArea()
scroll.setWidget(groups)
scroll.setFixedWidth((self.sorok_szama * 50) + 220)
scroll.setFixedHeight(600)
scroll.updateGeometry()
self.main_layout.addWidget(scroll)
self.main_layout.addLayout(lista_layout)
def create_torna_selection(self):
self.tournaments = QComboBox()
self.tournaments.setMinimumWidth(500)
self.tournaments.setModelColumn(0)
self.tournaments.activated.connect(self.torna_valasztas)
self.load_torna()
def load_torna(self):
torna = QSqlQueryModel()
query = QSqlQuery("select * from torna_settings where aktiv=2")
torna.setQuery(query)
if torna.record(0).value(0):
for i in range(torna.rowCount()):
self.tournaments.addItem(
torna.record(i).value(1),
torna.record(i).value(0)) # a value(0) a torna_id
def torna_valasztas(self, i):
self.torna_id = self.tournaments.itemData(i)
torna = QSqlQuery(
f"select * from torna_settings where torna_id={self.torna_id}")
torna.exec_()
while torna.next():
self.csoportok_szama = torna.value(3)
self.sorok_szama = torna.value(4)
self.variant = torna.value(5)
self.sets = torna.value(7)
self.legsperset = torna.value(8)
self.create_widgets()
self.set_layout()
# self.hatter.activate()
def clear_all_torna_match(self):
print("Rekordok törlése")
query = QSqlQuery(f"delete from torna_match where torna_id={torna_id}")
query.exec_()
def write_tables(self):
tabla_rekordok = []
for cs in range(len(self.csoportok)):
for sor in range(len(self.csoportok[cs])):
if self.csoportok[cs][sor]._get_player_id() != 0:
tabla_rekord = []
tabla_rekord.append(self.torna_id)
tabla_rekord.append(
self.csoportok[cs][sor]._get_player_id())
tabla_rekord.append(
self.csoportok[cs][sor]._get_csoport_number())
tabla_rekord.append(
self.csoportok[cs][sor]._get_csoport_sor())
tabla_rekordok.append(tabla_rekord)
insertDataQuery = QSqlQuery()
insertDataQuery.prepare("""
insert into torna_tablak (
torna_id,
player_id,
csoport_number,
csoport_sor
)
values (?, ?, ?, ?)
""")
for x in range(len(tabla_rekordok)):
for i in range(len(tabla_rekordok[x])):
insertDataQuery.addBindValue(tabla_rekordok[x][i])
insertDataQuery.exec_()
query = QSqlQuery(
f"update torna_settings set aktiv=1 where torna_id={self.torna_id}"
)
query.exec_()
def generate_boards(self):
sorrend = []
for i in range(self.resztvevok.count()):
item = self.resztvevok.item(i)
sorrend.append([item.text(), item.data(1)])
ujsorrend = sample(sorrend, len(sorrend))
# print(ujsorrend)
# print(self.csoportok_szama, self.sorok_szama)
# valami ilyesmi kell
# self._player_name = stream.readQString()
# self._player_id = stream.readInt16() # sor eseten p1, oszlopnál p2
atrakott = self.resztvevok.count()
for j in range(self.sorok_szama):
for i in range(self.csoportok_szama):
if atrakott > 0:
atrakott -= 1
self.csoportok[i][j]._set_player_name(
ujsorrend[atrakott][0])
self.csoportok[i][j]._set_player_id(ujsorrend[atrakott][1])
# print("csoport:", self.csoportok[i][j]._csoport_number, "sor:", self.csoportok[i][j]._csoport_sor, "j-sor", j, "i-csoport:", i)
for x in range(self.sorok_szama):
self.eredmenyek[i][j][x]._set_p1_id(
ujsorrend[atrakott][1])
self.eredmenyek[i][x][j]._set_p2_id(
ujsorrend[atrakott][1])
else:
break
if atrakott == 0:
break
self.resztvevok.clear()
def generate_match_records(self):
match_rekords = []
csoport_tabla = [6, 5, 4, 3, 2,
1] # todo táblához rendeléshez kell majd
for cs in range(self.csoportok_szama):
for sor in range(self.sorok_szama):
for oszlop in range(sor + 1, self.sorok_szama):
if self.eredmenyek[cs][sor][oszlop]._get_p1_id(
) != 0 and self.eredmenyek[cs][sor][oszlop]._get_p2_id(
) != 0:
match_id = (10000 * self.torna_id) + (
100 *
int(self.eredmenyek[cs][sor][oszlop]._get_p1_id())
) + int(self.eredmenyek[cs][sor][oszlop]._get_p2_id())
match_rekord = []
match_rekord.append(self.torna_id)
match_rekord.append(match_id)
match_rekord.append(
self.eredmenyek[cs][sor][oszlop]._get_p1_id())
match_rekord.append(
self.eredmenyek[cs][sor][oszlop]._get_p2_id())
match_rekord.append(self.variant)
match_rekord.append(self.sets)
match_rekord.append(self.legsperset)
match_rekord.append(csoport_tabla[cs])
match_rekords.append(match_rekord)
insertDataQuery = QSqlQuery()
insertDataQuery.prepare("""
insert into torna_match (
torna_id,
match_id,
player1_id,
player2_id,
variant,
sets,
legsperset,
tabla
)
values (?, ?, ?, ?, ?, ?, ?, ?)
""")
for x in range(len(match_rekords)):
for i in range(len(match_rekords[x])):
insertDataQuery.addBindValue(match_rekords[x][i])
insertDataQuery.exec_()
self.write_tables()
class QGroundObjectBuyMenu(QDialog):
layout_changed_signal = Signal(QTgoLayout)
def __init__(
self,
parent: QWidget,
ground_object: TheaterGroundObject,
game: Game,
current_group_value: int,
) -> None:
super().__init__(parent)
self.setMinimumWidth(350)
self.setWindowTitle("Buy ground object @ " + ground_object.obj_name)
self.setWindowIcon(EVENT_ICONS["capture"])
self.mainLayout = QGridLayout()
self.setLayout(self.mainLayout)
self.force_group_selector = QComboBox()
self.force_group_selector.setMinimumWidth(250)
self.layout_selector = QComboBox()
self.layout_selector.setMinimumWidth(250)
# Get the layouts and fill the combobox
tasks = []
if isinstance(ground_object, SamGroundObject):
role = GroupRole.AIR_DEFENSE
elif isinstance(ground_object, VehicleGroupGroundObject):
role = GroupRole.GROUND_FORCE
elif isinstance(ground_object, EwrGroundObject):
role = GroupRole.AIR_DEFENSE
tasks.append(GroupTask.EARLY_WARNING_RADAR)
else:
raise NotImplementedError(
f"Unhandled TGO type {ground_object.__class__}")
if not tasks:
tasks = role.tasks
for group in game.blue.armed_forces.groups_for_tasks(tasks):
self.force_group_selector.addItem(group.name, userData=group)
self.force_group_selector.setEnabled(
self.force_group_selector.count() > 1)
self.force_group_selector.adjustSize()
force_group = self.force_group_selector.itemData(
self.force_group_selector.currentIndex())
for layout in force_group.layouts:
self.layout_selector.addItem(layout.name, userData=layout)
self.layout_selector.adjustSize()
self.layout_selector.setEnabled(len(force_group.layouts) > 1)
selected_template = self.layout_selector.itemData(
self.layout_selector.currentIndex())
self.theater_layout = QTgoLayout(selected_template, force_group)
self.layout_selector.currentIndexChanged.connect(self.layout_changed)
self.force_group_selector.currentIndexChanged.connect(
self.force_group_changed)
template_selector_layout = QGridLayout()
template_selector_layout.addWidget(QLabel("Armed Forces Group:"), 0, 0,
Qt.AlignLeft)
template_selector_layout.addWidget(self.force_group_selector,
0,
1,
alignment=Qt.AlignRight)
template_selector_layout.addWidget(QLabel("Layout:"), 1, 0,
Qt.AlignLeft)
template_selector_layout.addWidget(self.layout_selector,
1,
1,
alignment=Qt.AlignRight)
self.mainLayout.addLayout(template_selector_layout, 0, 0)
self.template_layout = QGroundObjectTemplateLayout(
game,
ground_object,
self.theater_layout,
self.layout_changed_signal,
current_group_value,
)
self.template_layout.close_dialog_signal.connect(self.close_dialog)
self.mainLayout.addWidget(self.template_layout, 1, 0)
self.setLayout(self.mainLayout)
def force_group_changed(self) -> None:
# Prevent ComboBox from firing change Events
self.layout_selector.blockSignals(True)
unit_group = self.force_group_selector.itemData(
self.force_group_selector.currentIndex())
self.layout_selector.clear()
for layout in unit_group.layouts:
self.layout_selector.addItem(layout.name, userData=layout)
self.layout_selector.adjustSize()
# Enable if more than one template is available
self.layout_selector.setEnabled(len(unit_group.layouts) > 1)
# Enable Combobox Signals again
self.layout_selector.blockSignals(False)
self.layout_changed()
def layout_changed(self) -> None:
self.layout()
self.theater_layout.layout = self.layout_selector.itemData(
self.layout_selector.currentIndex())
self.theater_layout.force_group = self.force_group_selector.itemData(
self.force_group_selector.currentIndex())
self.layout_changed_signal.emit(self.theater_layout)
def close_dialog(self) -> None:
self.accept()
