class ScopeShotTimer(QDialog):
def __init__(self):
super(ScopeShotTimer, self).__init__()
self.initUI()
def initUI(self):
self.count = 0
self.timer = QtCore.QTimer(self)
self.timer.timeout.connect(self.Time)
self.timer.start(1000)
self.lcd = QLCDNumber(self)
# get the palette
palette = self.lcd.palette()
# foreground color
palette.setColor(palette.WindowText, QtGui.QColor(85, 85, 255))
# background color
palette.setColor(palette.Background, QtGui.QColor(0, 170, 255))
# "light" border
palette.setColor(palette.Light, QtGui.QColor(255, 0, 0))
# "dark" border
palette.setColor(palette.Dark, QtGui.QColor(0, 255, 0))
# set the palette
self.lcd.setPalette(palette)
self.lcd.setMinimumHeight(100)
self.lcd.setMinimumWidth(148)
self.lcd.display(self.count)
diologGrid = QGridLayout()
diologGrid.addWidget(self.lcd, 0, 0)
self.okButton = QPushButton('Capture Scope Shot', self)
self.okButton.clicked[bool].connect(self.close)
diologGrid.addWidget(self.okButton, 0, 1)
self.setLayout(diologGrid)
self.setGeometry(200, 200, 150, 100)
self.setWindowTitle('Scope Capture')
self.setWindowIcon(QIcon('xbox_icon.ico'))
def Time(self):
# self.lcd.display(strftime("%H"+":"+"%M"+":"+"%S"))
self.count += 1
self.lcd.display(self.count)
if self.count == 120:
print '\a'
class Calendar(QWidget):
# keep the current time as class variable for reference
currentDay = datetime.now().day
currentMonth = datetime.now().month
currentYear = datetime.now().year
def __init__(self):
super().__init__()
folder = path.dirname(__file__)
self.icon_folder = path.join(folder, "icons")
self.setWindowTitle("Planner")
self.setWindowIcon(
QtGui.QIcon(path.join(self.icon_folder, 'window.png')))
self.setGeometry(300, 200, 600, 400)
self.initUI()
def initUI(self):
self.calendar = QCalendarWidget()
self.calendar.setGeometry(0, 0, 300, 300)
self.calendar.setGridVisible(True)
# don't allow going back to past months in calendar
self.calendar.setMinimumDate(
QDate(self.currentYear, self.currentMonth, 1))
# format for dates in calendar that have events
self.fmt = QTextCharFormat()
self.fmt.setBackground(QColor(255, 165, 0, 100))
# format for the current day
cur_fmt = QTextCharFormat()
cur_fmt.setBackground(QColor(0, 255, 90, 70))
# format to change back to if all events are deleted
self.delfmt = QTextCharFormat()
self.delfmt.setBackground(Qt.transparent)
# check if json file exists, if it does load the data from it
file_exists = path.isfile(
path.join(path.dirname(__file__), "data.json"))
if file_exists:
with open("data.json", "r") as json_file:
self.data = json.load(json_file)
else:
self.data = {}
# delete data from days prior to the current day
cur = QDate.currentDate()
for date in list(self.data.keys()):
check_date = QDate.fromString(date, "dMyyyy")
if cur.daysTo(check_date) <= 0 and cur != check_date:
self.data.pop(date)
else:
self.calendar.setDateTextFormat(check_date, self.fmt)
# mark current day in calendar
current = str(self.currentDay) + str(self.currentMonth) + str(
self.currentYear)
self.calendar.setDateTextFormat(QDate.fromString(current, "dMyyyy"),
cur_fmt)
# organize buttons and layouts for display
addButton = QPushButton("Add Event")
addButton.clicked.connect(self.addNote)
editButton = QPushButton("Edit")
editButton.clicked.connect(self.editNote)
delButton = QPushButton("Delete")
delButton.clicked.connect(self.delNote)
self.calendar.selectionChanged.connect(self.showDateInfo)
self.calendar.selectionChanged.connect(self.labelDate)
self.calendar.selectionChanged.connect(self.highlightFirstItem)
self.note_group = QListWidget()
self.note_group.setSortingEnabled(True)
self.note_group.setStyleSheet("QListView::item {height: 40px;}")
self.label = QLabel()
label_font = QtGui.QFont("Gabriola", 18)
self.label.setFont(label_font)
self.labelDate()
self.showDateInfo()
labelp = QLabel()
pixmap = QPixmap(path.join(self.icon_folder, 'calendar.png'))
labelp.setPixmap(pixmap)
# set up a timer that automatically updates every second
self.lcd = QLCDNumber()
self.lcd.setSegmentStyle(QLCDNumber.Filled)
self.lcd.setMinimumWidth(80)
timer = QTimer(self)
timer.timeout.connect(self.showTime)
timer.start(1000)
self.showTime()
hbox1 = QHBoxLayout()
hbox1.addStretch(1)
hbox1.addWidget(self.label)
hbox1.addStretch(1)
hbox2 = QHBoxLayout()
hbox2.addWidget(addButton)
hbox2.addWidget(editButton)
hbox2.addWidget(delButton)
hbox3 = QHBoxLayout()
hbox3.addStretch(1)
hbox3.addWidget(labelp)
hbox3.addWidget(self.lcd)
vbox = QVBoxLayout()
vbox.addLayout(hbox1)
vbox.addWidget(self.note_group)
vbox.addLayout(hbox2)
vbox.addLayout(hbox3)
hbox = QHBoxLayout()
hbox.addWidget(self.calendar)
hbox.addLayout(vbox)
self.setLayout(hbox)
def showDateInfo(self):
# add events to selected date
date = self.getDate()
self.note_group.clear()
if date in self.data:
self.note_group.addItems(self.data[date])
def addNote(self):
# adding notes for selected date
# if a note starts with any number other than 0, 1, 2
# add a 0 before it so that we can easily sort events
# by start time
date = self.getDate()
row = self.note_group.currentRow()
title = "Add {}".format("event")
string, ok = QInputDialog.getText(self, title, title)
if ok and string:
if string[0].isdigit() and string[0] not in ["0", "1", "2"]:
string = string.replace(string[0], "0" + string[0])
self.note_group.insertItem(row, string)
self.calendar.setDateTextFormat(QDate.fromString(date, "dMyyyy"),
self.fmt)
if date in self.data:
self.data[date].append(string)
else:
self.data[date] = [string]
def delNote(self):
# delete the currently selected item
date = self.getDate()
row = self.note_group.currentRow()
item = self.note_group.item(row)
if not item:
return
reply = QMessageBox.question(self, "Remove", "Remove",
QMessageBox.Yes | QMessageBox.No)
if reply == QMessageBox.Yes:
item = self.note_group.takeItem(row)
self.data[date].remove(item.text())
if not self.data[date]:
del (self.data[date])
self.calendar.setDateTextFormat(
QDate.fromString(date, "dMyyyy"), self.delfmt)
del (item)
def editNote(self):
# edit the currently selected item
date = self.getDate()
row = self.note_group.currentRow()
item = self.note_group.item(row)
if item:
copy = item.text()
title = "Edit event"
string, ok = QInputDialog.getText(self, title, title,
QLineEdit.Normal, item.text())
if ok and string:
self.data[date].remove(copy)
self.data[date].append(string)
if string[0].isdigit() and string[0] not in ["0", "1", "2"]:
string = string.replace(string[0], "0" + string[0])
item.setText(string)
def getDate(self):
# parse the selected date into usable string form
select = self.calendar.selectedDate()
date = str(select.day()) + str(select.month()) + str(select.year())
return date
def labelDate(self):
# label to show the long name form of the selected date
# format US style like "Thursday, February 20, 2020"
select = self.calendar.selectedDate()
weekday, month = select.dayOfWeek(), select.month()
day, year = str(select.day()), str(select.year())
week_day, word_month = QDate.longDayName(weekday), QDate.longMonthName(
month)
self.label.setText(week_day + ", " + word_month + " " + day + ", " +
year)
def highlightFirstItem(self):
# highlight the first item immediately after switching selection
if self.note_group.count() > 0:
self.note_group.setCurrentRow(0)
def showTime(self):
# keep the current time updated
time = QTime.currentTime()
text = time.toString("hh:mm")
if time.second() % 2 == 0:
text.replace(text[2], '')
self.lcd.display(text)
def closeEvent(self, e):
# save all data into json file when user closes app
with open("data.json", "w") as json_file:
json.dump(self.data, json_file)
e.accept()
class Objetives(QWidget):
NumButtons = 3
def __init__(self, parent=None):
super(Objetives, self).__init__(parent)
self.createDisplay()
self.createDisplayAverage()
self.createButtons()
self.numVictory = 0
self.numLosses = 0
mainLayout = QGridLayout()
mainLayout.addWidget(self.displayLCD)
mainLayout.addWidget(self.horizontalGroupBox)
mainLayout.addWidget(self.displayWinPercent)
self.setLayout(mainLayout)
self.setWindowTitle("Objetives")
def createButtons(self):
self.horizontalGroupBox = QGroupBox("")
layout = QGridLayout()
self.victoryButton = self.createButton("Victory", "+",self.addVictoryOrLosses)
self.lossesButton = self.createButton("Losses", "+",self.addVictoryOrLosses)
self.victoryDecreaseButton = self.createButton("DV","-",self.addVictoryOrLosses)
self.losseDecreaseButton = self.createButton("DL","-",self.addVictoryOrLosses)
self.lossesButton.setMinimumWidth(150)
self.victoryButton.setMinimumWidth(150)
self.losseDecreaseButton.setMaximumHeight(20)
self.victoryDecreaseButton.setMaximumHeight(20)
layout.addWidget(self.victoryButton, 0, 0, 1, 1)
layout.addWidget(self.lossesButton, 0, 2, 1, 1)
layout.addWidget(self.victoryDecreaseButton, 1, 0, 1, 1)
layout.addWidget(self.losseDecreaseButton, 1, 2, 1, 1)
self.horizontalGroupBox.setLayout(layout)
def createDisplayAverage(self):
self.displayWinPercent = QGroupBox("Wins")
layout = QHBoxLayout()
self.progressBar = QProgressBar()
self.progressBar.setRange(0, 100)
# self.progressBar.setValue(5000)
layout.addWidget(self.progressBar)
self.displayWinPercent.setLayout(layout)
def createDisplay(self):
self.displayLCD = QGroupBox("")
layout = QHBoxLayout()
paletteLosses = QPalette()
paletteVictory = QPalette()
paletteLosses.setColor(paletteLosses.WindowText, QColor(255, 000, 000))
paletteVictory.setColor(paletteVictory.WindowText, QColor(000, 255, 000))
self.lossesLcd = QLCDNumber(3)
self.lossesLcd.setSegmentStyle(QLCDNumber.Filled)
self.lossesLcd.setPalette(paletteLosses)
self.victoryLcd = QLCDNumber(3)
self.victoryLcd.setSegmentStyle(QLCDNumber.Filled)
self.victoryLcd.setPalette(paletteVictory)
self.lossesLcd.setMinimumHeight(100)
self.victoryLcd.setMinimumHeight(100)
self.lossesLcd.setMinimumWidth(150)
self.victoryLcd.setMinimumWidth(150)
layout.addWidget(self.victoryLcd)
layout.addWidget(self.lossesLcd)
self.displayLCD.setLayout(layout)
def addVictoryOrLosses(self):
clickedButton = self.sender()
clickedOperator = clickedButton.text()
operand = float(1)
if clickedOperator == "Victory":
self.numVictory = self.numVictory + 1
self.victoryLcd.display(str(self.numVictory))
if clickedOperator == "DV":
self.numVictory = self.numVictory - 1
self.victoryLcd.display(str(self.numVictory))
if clickedOperator == "Losses":
self.numLosses = self.numLosses + 1
self.lossesLcd.display(str(self.numLosses))
if clickedOperator == "DL":
self.numLosses = self.numLosses - 1
self.lossesLcd.display(str(self.numLosses))
self.calculateAverage()
def calculateAverage(self):
total = self.numVictory + self.numLosses
# self.progressBar.setValue((int(self.numVictory / total * 100)))
self.progressBar.setValue(100)
# self.victoryLcdAv.display(str(int(self.numVictory / total * 100)))
# self.lossesLcdAv.display(str(int(self.numLosses / total * 100)))
def createButton(self, text, op, member):
button = Button(text,op)
button.clicked.connect(member)
return button
class OmniRigQTControls:
def __init__(self, operatingAsClient, sendCommandFunction=None):
self.operatingAsClient = operatingAsClient
self.omnirigObject = None
self.omniRigInfo = {}
self.sendCommandFunction = sendCommandFunction
self.blackColorPalette = QPalette()
self.blackColorPalette.setColor(QPalette.WindowText, QColor("black"))
self.redColorPalette = QPalette()
self.redColorPalette.setColor(QPalette.WindowText, QColor("red"))
self.boldFont = QFont()
self.boldFont.setBold(True)
self.regularFont = QFont()
self.regularFont.setBold(False)
self.labelRigName = QLabel("Rig is not responding")
self.rigSelectGroupBox = QGroupBox("Rig select:")
self.radioBtnTRX1 = QRadioButton("Rig 1")
self.radioBtnTRX1.setChecked(True)
self.radioBtnTRX1.toggled.connect(self.refreshRigInformation)
self.radioBtnTRX2 = QRadioButton("Rig 2")
self.radioBtnTRX2.toggled.connect(self.refreshRigInformation)
hboxRigSelect = QHBoxLayout()
hboxRigSelect.addWidget(self.radioBtnTRX1)
hboxRigSelect.addWidget(self.radioBtnTRX2)
hboxRigSelect.addWidget(self.labelRigName)
hboxRigSelect.addStretch()
self.rigSelectGroupBox.setLayout(hboxRigSelect)
self.rigSelectGroupBox.setMaximumWidth(360)
self.lcdTrxFrequency = QLCDNumber(10)
self.lcdTrxFrequency.display('00.000.00')
self.lcdTrxFrequency.setPalette(self.blackColorPalette)
self.lcdTrxFrequency.setMinimumHeight(50)
self.lcdTrxFrequency.setMaximumHeight(50)
self.lcdTrxFrequency.setMaximumWidth(275)
self.lcdTrxFrequency.setMinimumWidth(275)
self.labelRigModeLSB = QLabel('LSB')
self.labelRigModeLSB.setFont(self.boldFont)
self.labelRigModeLSB.setEnabled(False)
self.labelRigModeUSB = QLabel('USB')
self.labelRigModeUSB.setFont(self.boldFont)
self.labelRigModeUSB.setEnabled(False)
vboxMiddlePanel = QVBoxLayout()
vboxMiddlePanel.addWidget(self.labelRigModeLSB)
vboxMiddlePanel.addWidget(self.labelRigModeUSB)
hboxMiddlePanel = QHBoxLayout()
hboxMiddlePanel.addLayout(vboxMiddlePanel)
hboxMiddlePanel.addStretch()
self.btnBack500Hz = QPushButton("<--")
self.btnBack500Hz.setFixedWidth(50)
self.btnForward500Hz = QPushButton("-->")
self.btnForward500Hz.setFixedWidth(50)
self.btnForward500Hz.clicked.connect(self.btnOmniRigPlus500HzClick)
self.btnOmniRigUSB = QPushButton("USB")
self.btnOmniRigUSB.clicked.connect(self.btnOmniUSBClick)
self.btnOmniRigUSB.setFixedWidth(50)
self.btnOmniRigLSB = QPushButton("LSB")
self.btnOmniRigLSB.clicked.connect(self.btnOmniLSBClick)
self.btnOmniRigLSB.setFixedWidth(50)
hboxRigCATControl = QHBoxLayout()
hboxRigCATControl.addWidget(self.btnBack500Hz)
hboxRigCATControl.addWidget(self.btnForward500Hz)
hboxRigCATControl.addStretch()
hboxRigCATControl.addWidget(self.btnOmniRigLSB)
hboxRigCATControl.addWidget(self.btnOmniRigUSB)
hboxRigCATControl.addStretch(1)
hboxMainLayout = QHBoxLayout()
hboxMainLayout.addWidget(self.lcdTrxFrequency)
hboxMainLayout.addLayout(hboxMiddlePanel)
self.vboxMainLayout = QVBoxLayout()
self.vboxMainLayout.addWidget(self.rigSelectGroupBox)
self.vboxMainLayout.addLayout(hboxMainLayout)
if self.operatingAsClient is True:
self.vboxMainLayout.addLayout(hboxRigCATControl)
def setOmnirigObject(self, omnirigObject):
self.omnirigObject = omnirigObject
def btnOmniRigPlus500HzClick(self):
try:
self.omnirigObject = win32.Dispatch("OmniRig.OmniRigX")
except:
pass
if self.omnirigObject is not None and self.operatingAsClient is False:
if self.radioBtnTRX1.isChecked():
self.omnirigObject.Rig1.SetSimplexMode(str(self.omnirigObject.Rig1.Freq+500))
else:
self.omnirigObject.Rig2.SetSimplexMode(str(self.omnirigObject.Rig1.Freq+500))
if self.operatingAsClient is True and self.sendCommandFunction is not None:
self.sendCommandFunction('+500=1')
def btnOmniLSBClick(self):
try:
self.omnirigObject = win32.Dispatch("OmniRig.OmniRigX")
except:
pass
if self.omnirigObject is not None and self.operatingAsClient is False:
if self.radioBtnTRX1.isChecked():
self.omnirigObject.Rig1.Mode = '67108864'
else:
self.omnirigObject.Rig2.Mode = '67108864'
if self.operatingAsClient is True and self.sendCommandFunction is not None:
self.sendCommandFunction('setLSB=1')
def btnOmniUSBClick(self):
try:
self.omnirigObject = win32.Dispatch("OmniRig.OmniRigX")
except:
pass
if self.omnirigObject is not None and self.operatingAsClient is False:
if self.radioBtnTRX1.isChecked():
self.omnirigObject.Rig1.Mode = '33554432'
else:
self.omnirigObject.Rig2.Mode = '33554432'
if self.operatingAsClient is True and self.sendCommandFunction is not None:
self.sendCommandFunction('setUSB=1')
def setDisplayFreq(self, txtFreq):
self.lcdTrxFrequency.display(txtFreq)
def setOmniRigErrorText(self, msgText):
self.labelRigName.setText(msgText)
self.labelRigName.setPalette(self.redColorPalette)
def setRigStatus(self, rigType):
self.labelRigName.setText(rigType)
self.labelRigName.setPalette(self.blackColorPalette)
def getRigsInformation(self):
return self.omniRigInfo
def disableControls(self):
self.radioBtnTRX1.setEnabled(False)
self.radioBtnTRX2.setEnabled(False)
def refreshRigInformation(self):
rignum = '2'
if self.radioBtnTRX1.isChecked():
rignum = '1'
if len(self.omniRigInfo) > 1:
self.radioBtnTRX1.setText(self.omniRigInfo['1'].getRigType())
self.radioBtnTRX2.setText(self.omniRigInfo['2'].getRigType())
freqTxt = self.omniRigInfo[rignum].getRigFreq()
self.setDisplayFreq(self.addDotsToFreq(freqTxt))
self.setRigStatus(self.omniRigInfo[rignum].getRigStatus())
if freqTxt == 0:
self.labelRigModeUSB.setEnabled(False)
self.labelRigModeLSB.setEnabled(False)
else:
if self.omniRigInfo[rignum].getRigMode() == 'LSB':
self.labelRigModeUSB.setEnabled(False)
self.labelRigModeLSB.setEnabled(True)
else:
self.labelRigModeUSB.setEnabled(True)
self.labelRigModeLSB.setEnabled(False)
def setRigInformation(self, omniRigInfo):
self.omniRigInfo = omniRigInfo
self.refreshRigInformation()
def addDotsToFreq(self, freqvalue):
freqTxt = str(freqvalue)
if len(freqTxt) < 6:
freqTxt = '00000000'
firstPart = freqTxt[:-6]
if len(freqTxt) == 8:
mainPart = freqTxt[:7]
middlePart = mainPart[2:5]
lastPart = mainPart[5:]
else:
mainPart = freqTxt[:6]
middlePart = mainPart[1:4]
lastPart = mainPart[4:]
return firstPart+"."+middlePart+"."+lastPart
def getGUI(self):
return self.vboxMainLayout
class UI(object):
def setupUI(self, Widget):
layout0 = QHBoxLayout()
self.addImageBtn = QPushButton('Dodaj zdjęcie', self)
layout0.addWidget(self.addImageBtn)
layoutA = QHBoxLayout()
self.originalBtn = QPushButton('Oryginał', self)
self.negativeBtn = QPushButton('Negatyw', self)
self.grayedOutBtn = QPushButton('Szarość', self)
self.histEqualizeBtn = QPushButton('Normalizacja histogramu', self)
self.binarizationBtn = QPushButton('Binaryzacja', self)
self.blurBtn = QPushButton('Rozmycie', self)
self.skelBtn = QPushButton('Szkieletyzacja', self)
self.erosionBtn = QPushButton('Erozja', self)
layoutA.addWidget(self.originalBtn)
layoutA.addWidget(self.negativeBtn)
layoutA.addWidget(self.grayedOutBtn)
layoutA.addWidget(self.histEqualizeBtn)
layoutA.addWidget(self.binarizationBtn)
layoutA.addWidget(self.blurBtn)
layoutA.addWidget(self.skelBtn)
layoutA.addWidget(self.erosionBtn)
layoutB = QHBoxLayout()
self.gaussBtn = QPushButton('Rozmycie Gaussa', self)
self.medianBtn = QPushButton('Filtr medianowy', self)
self.rgb2grayBtn = QPushButton('Przestrzeń kolorów RGB->GRAY', self)
self.rgb2hsvBtn = QPushButton('Przestrzeń kolorów RGB->HSV', self)
self.cannyBtn = QPushButton('Detekcja krawędzi', self)
self.otsuBtn = QPushButton('Segmentacja Otsu', self)
layoutB.addWidget(self.gaussBtn)
layoutB.addWidget(self.medianBtn)
layoutB.addWidget(self.rgb2grayBtn)
layoutB.addWidget(self.rgb2hsvBtn)
layoutB.addWidget(self.cannyBtn)
layoutB.addWidget(self.otsuBtn)
layoutC = QHBoxLayout()
self.segHistBtn = QPushButton(
'Segmentacja - wyznaczanie progów na podstawie histogramu', self)
self.watershedBtn = QPushButton('Segmentacja - watershed algorithm',
self)
self.brighterBtn = QPushButton('Jasność', self)
layoutC.addWidget(self.segHistBtn)
layoutC.addWidget(self.watershedBtn)
layoutC.addWidget(self.brighterBtn)
self.chkGroup = QButtonGroup()
for i, v in enumerate(('Jaśniej', 'Ciemniej')):
self.chk = QCheckBox(v)
self.chkGroup.addButton(self.chk, i)
layoutC.addWidget(self.chk)
self.chkGroup.buttons()[0].setChecked(True)
layoutD = QHBoxLayout()
self.rotatingBtn = QPushButton('Rotacja', self)
self.slider = QSlider(Qt.Horizontal)
self.slider.setMaximum(360)
self.slider.setMinimum(0)
self.lcd = QLCDNumber(3)
self.lcd.setMaximumHeight(25)
self.lcd.setMinimumWidth(100)
self.lcd.setSegmentStyle(QLCDNumber.Flat)
self.scalingBtn = QPushButton('Skalowanie', self)
self.slider1 = QSlider(Qt.Horizontal)
self.slider1.setMinimum(50)
self.slider1.setMaximum(200)
self.lcd1 = QLCDNumber(4)
self.lcd1.setMaximumHeight(25)
self.lcd1.setMinimumWidth(100)
self.lcd1.setSegmentStyle(QLCDNumber.Flat)
self.slider2 = QSlider(Qt.Horizontal)
self.slider2.setMinimum(1)
self.slider2.setMaximum(10)
self.lcd2 = QLCDNumber(4)
self.lcd2.setMaximumHeight(25)
self.lcd2.setMinimumWidth(100)
self.lcd2.setSegmentStyle(QLCDNumber.Flat)
layoutD.addWidget(self.rotatingBtn)
layoutD.addWidget(self.slider)
layoutD.addWidget(self.lcd)
layoutD.addWidget(self.scalingBtn)
layoutD.addWidget(self.slider1)
layoutD.addWidget(self.lcd1)
layoutD.addWidget(self.slider2)
layoutD.addWidget(self.lcd2)
layoutE = QHBoxLayout()
self.image = QLabel(self)
img = cv.imread('lenna.bmp')
img = cv.cvtColor(img, cv.COLOR_BGR2RGB)
qimg = QImage(img.data, img.shape[1], img.shape[0],
QImage.Format_RGB888)
pixmap = QPixmap.fromImage(qimg)
self.image.setPixmap(pixmap)
layoutE.addWidget(self.image)
layoutE.setAlignment(Qt.AlignCenter)
mainLayout = QVBoxLayout()
mainLayout.addLayout(layoutA)
mainLayout.addLayout(layoutB)
mainLayout.addLayout(layoutC)
mainLayout.addLayout(layoutD)
mainLayout.addLayout(layoutE)
mainLayout.addLayout(layout0)
self.setLayout(mainLayout) # przypisanie układu do okna głównego
self.setWindowTitle('Przetwarzanie obrazów')
self.resize(1366, 768)
class Phase10PlayerWidget(GamePlayerWidget):
roundWinnerSet = QtCore.pyqtSignal(str)
def __init__(self, nick, engine, bgroup=None, parent=None):
self.engine = engine
self.current_phase = min(
self.engine.getRemainingPhasesFromPlayer(nick))
self.phases_in_order = self.engine.getPhasesInOrderFlag()
self.bgroup = bgroup
super(Phase10PlayerWidget, self).__init__(
nick, PlayerColours[self.engine.getListPlayers().index(nick)],
parent)
def initUI(self):
css = ("QGroupBox {{ font-size: 28px;"
"font-weight: bold; color:rgb({},{},{});}}")
self.setStyleSheet(css.format(self.pcolour.red(),
self.pcolour.green(),
self.pcolour.blue()))
self.setTitle(self.player)
super(Phase10PlayerWidget, self).initUI()
trashWidget = QWidget()
trashWidget.setLayout(self.mainLayout)
self.mainLayout = QVBoxLayout(self)
self.mainLayout.addStretch()
self.upperLayout = QHBoxLayout()
self.mainLayout.addLayout(self.upperLayout)
self.upperLayout.addStretch()
self.phaseNameLabel = QLabel(self)
self.phaseNameLabel.setStyleSheet(
"font-weight: bold; font-size: 24px;")
self.updatePhaseName()
self.upperLayout.addWidget(self.phaseNameLabel)
self.upperLayout.addStretch()
self.lowerLayout = QHBoxLayout()
self.mainLayout.addLayout(self.lowerLayout)
self.mainLayout.addStretch()
self.phaseLabelsLayout = QGridLayout()
self.phaseLabelsLayout.setSpacing(5)
self.checkboxLayout = QVBoxLayout()
self.scoreLCD = QLCDNumber(self)
self.scoreLCD.setSegmentStyle(QLCDNumber.Flat)
self.mainLayout.addWidget(self.scoreLCD)
self.scoreLCD.setNumDigits(3)
self.scoreLCD.setMinimumWidth(100)
css = "QLCDNumber {{ color:rgb({},{},{});}}"
self.scoreLCD.setStyleSheet(css.format(self.pcolour.red(),
self.pcolour.green(),
self.pcolour.blue()))
# Left part - score
self.lowerLayout.addWidget(self.iconlabel)
self.lowerLayout.addWidget(self.scoreLCD)
self.lowerLayout.addLayout(self.phaseLabelsLayout)
self.lowerLayout.addLayout(self.checkboxLayout)
self.iconlabel.setMinimumSize(60, 60)
# self.scoreLCD.setMinimumWidth(100)
# self.scoreLCD.setMaximumWidth(200)
# self.scoreLCD.setMinimumHeight(60)
# self.scoreLCD.setMaximumHeight(80)
self.scoreLCD.display(self.engine.getScoreFromPlayer(self.player))
# Middle part - Phase list
self.phaseLabels = list()
for phase in range(1, 11):
label = Phase10Label(phase, self)
if phase == self.current_phase:
label.setCurrent()
elif self.engine.hasPhaseCompleted(self.player, phase):
label.setPassed()
self.phaseLabels.append(label)
self.phaseLabelsLayout.addWidget(
label, (phase-1)/5, (phase-1) % 5, 1, 1)
# Middle part - Inputs
self.roundWinnerRadioButton = QRadioButton()
self.bgroup.addButton(self.roundWinnerRadioButton)
self.checkboxLayout.addWidget(self.roundWinnerRadioButton)
self.roundPhaseClearedCheckbox = QCheckBox(self)
self.checkboxLayout.addWidget(self.roundPhaseClearedCheckbox)
self.roundScore = Phase10ScoreSpinBox(self)
self.roundScore.setMaximumWidth(90)
self.roundScore.valueChanged.connect(self.updateRoundPhaseCleared)
self.lowerLayout.addWidget(self.roundScore)
self.roundWinnerRadioButton.toggled.connect(
self.roundScore.setDisabled)
self.roundWinnerRadioButton.toggled.connect(
self.roundPhaseClearedCheckbox.setDisabled)
self.roundWinnerRadioButton.toggled.connect(
self.roundPhaseClearedCheckbox.setChecked)
self.roundWinnerRadioButton.toggled.connect(self.roundWinnerSetAction)
self.retranslateUI()
def retranslateUI(self):
self.roundWinnerRadioButton.setText(
i18n("Phase10PlayerWidget", "Winner"))
self.roundPhaseClearedCheckbox.setText(
i18n("Phase10PlayerWidget", "Completed"))
self.updatePhaseName()
def updateDisplay(self, points, completed_phases, remaining_phases):
if len(remaining_phases) == 0:
self.current_phase = 0
else:
self.current_phase = min(remaining_phases)
self.roundWinnerRadioButton.setDown(True)
if points >= 1000:
self.scoreLCD.setNumDigits(4)
self.scoreLCD.display(points)
self.roundScore.setValue(5)
self.roundScore.clear()
self.roundPhaseClearedCheckbox.setChecked(False)
for phase, label in enumerate(self.phaseLabels, start=1):
if phase == self.current_phase and not self.engine.getWinner():
if not label.isCurrent():
label.setCurrent()
elif phase in completed_phases:
if not label.isPassed():
label.setPassed()
else:
if not label.isRemaining():
label.setRemaining()
self.updatePhaseName()
def getScore(self):
if self.isRoundWinner():
return 0
try:
return int(self.roundScore.value())
except Exception:
return -1
def switchPhasesInOrder(self, in_order):
self.phases_in_order = in_order
if not self.phases_in_order:
return
self.phaseLabels[self.current_phase-1].setRemaining()
for label in self.phaseLabels:
if label.isRemaining():
label.setCurrent()
self.current_phase = label.getNumber()
break
def updatePhaseSelected(self, phaselabel):
if phaselabel.isRemaining():
self.current_phase = phaselabel.getNumber()
for label in self.phaseLabels:
if label.isCurrent():
label.setRemaining()
phaselabel.setCurrent()
self.updatePhaseName()
def updatePhaseName(self):
phasenames = getPhaseNames(self.engine.getPhases())
self.phaseNameLabel.setText(phasenames[self.current_phase-1])
def updateRoundPhaseCleared(self, value):
try:
score = int(self.roundScore.text())
except Exception:
self.roundPhaseClearedCheckbox.setChecked(False)
return
if score < 0:
if not self.roundWinnerRadioButton.isChecked():
self.roundPhaseClearedCheckbox.setChecked(False)
return
if (score % 5 != 0):
return
if (score >= 50):
self.roundWinnerRadioButton.setChecked(False)
self.roundPhaseClearedCheckbox.setChecked(False)
elif (score == 0):
self.roundWinnerRadioButton.setChecked(True)
self.roundPhaseClearedCheckbox.setChecked(True)
else:
self.roundWinnerRadioButton.setChecked(False)
self.roundPhaseClearedCheckbox.setChecked(True)
def mousePressEvent(self, event):
child = self.childAt(event.pos())
if child is None:
self.roundScore.setFocus()
elif type(child) == Phase10Label and not self.phases_in_order:
self.updatePhaseSelected(child)
return QGroupBox.mousePressEvent(self, event)
#
def isRoundWinner(self): return self.roundWinnerRadioButton.isChecked()
def getRoundPhase(self): return self.current_phase
def isRoundCleared(self): return self.roundPhaseClearedCheckbox.isChecked()
def roundWinnerSetAction(self, isset):
if isset:
self.roundWinnerSet.emit(self.player)
def reset(self): pass
def finish(self):
self.roundWinnerRadioButton.toggled.disconnect(
self.roundScore.setDisabled)
self.roundWinnerRadioButton.toggled.disconnect(
self.roundPhaseClearedCheckbox.setDisabled)
self.roundWinnerRadioButton.toggled.disconnect(
self.roundPhaseClearedCheckbox.setChecked)
self.roundWinnerRadioButton.toggled.disconnect(
self.roundWinnerSetAction)
self.roundWinnerRadioButton.setDisabled(True)
self.roundPhaseClearedCheckbox.setDisabled(True)
self.roundScore.setDisabled(True)
def setColour(self, colour):
self.pcolour = colour
css = ("QGroupBox {{ font-size: 28px; font-weight: bold;"
"color:rgb({},{},{});}}")
self.setStyleSheet(css.format(self.pcolour.red(),
self.pcolour.green(),
self.pcolour.blue()))
