class ApplicationWindow(QDialog):
def __init__(self, ):
super().__init__()
self.setupUi(self)
self.initUI()
self.setup_timer()
def setupUi(self, Dialog):
self.verticalLayout = QVBoxLayout(Dialog)
self.lcd_reading = QLCDNumber(Dialog)
self.lcd_reading.setMinimumSize(QtCore.QSize(300, 100))
self.verticalLayout.addWidget(self.lcd_reading)
def initUI(self):
self.setFixedSize(330, 180)
self.setWindowTitle("PyQt CAN bus Dashboard")
screen = QtWidgets.QDesktopWidget().screenGeometry()
size = self.geometry()
self.move(
(screen.width()-size.width())/2,
(screen.height()-size.height())/2)
def setup_timer(self):
self.timer = QtCore.QTimer(self)
self.timer.setInterval(OPTIONS['update_time'])
self.timer.timeout.connect(self.update_reading)
self.timer.start()
def get_value(self):
msg = node1.recv(timeout=0.001)
value = list(msg.data)[0]
return value
def update_reading(self):
try:
reading = self.get_value()
self.lcd_reading.display(str(reading))
except:
pass
def closeEvent(self, event):
self.timer.stop()
class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
self.timer = QTimer(self)
self.formatted_time = FormattedTime(0, 0, 0)
self.state = TimerState.INACTIVE
self.splits = []
self.init_menus()
self.init_UI()
def init_menus(self):
menubar = self.menuBar()
fileMenu = menubar.addMenu('&File')
exitAct = QAction(QIcon('exit.png'), '&Exit', self)
exitAct.setShortcut('Ctrl+Q')
exitAct.setStatusTip('Exit application')
exitAct.triggered.connect(qApp.quit)
fileMenu.addAction(exitAct)
viewMenu = menubar.addMenu('View')
viewStatAct = QAction('View statusbar', self, checkable=True)
viewStatAct.setStatusTip('View statusbar')
viewStatAct.setChecked(True)
viewStatAct.triggered.connect(self.toggle_menu)
viewMenu.addAction(viewStatAct)
def init_UI(self):
wid = QWidget(self)
self.setCentralWidget(wid)
QToolTip.setFont(QFont('SansSerif', 10))
# ---
self.start_stop_button = QPushButton('Start')
self.start_stop_button.clicked.connect(self.start_stop)
# ---
self.pause_button = QPushButton('Pause')
self.pause_button.resize(self.pause_button.sizeHint())
self.pause_button.clicked.connect(self.pause_timer)
self.pause_button.setEnabled(False)
# ---
self.split_button = QPushButton("Split")
self.split_button.clicked.connect(self.split)
self.split_button.setEnabled(False)
# ---
self.lcd = QLCDNumber(self)
self.lcd.setMinimumSize(QSize(150, 150))
self.lcd.setSegmentStyle(QLCDNumber.Flat)
self.lcd.setDigitCount(len(str(self.formatted_time)))
self.lcd.display(str(self.formatted_time))
# ---
self.splits_table = QTableWidget()
self.splits_table.setMinimumSize(QSize(150, 200))
self.splits_table.setRowCount(len(self.splits))
self.splits_table.setColumnCount(1)
self.splits_table.setShowGrid(False)
self.splits_table.verticalHeader().setDefaultSectionSize(20)
self.splits_table.verticalHeader().setVisible(False)
self.splits_table.horizontalHeader().setVisible(False)
self.update_splits_table()
# ---
vbox = QVBoxLayout()
vbox.addStretch(1)
vbox.addWidget(self.lcd)
vbox.addWidget(self.splits_table)
vbox.addWidget(self.start_stop_button)
vbox.addWidget(self.pause_button)
vbox.addWidget(self.split_button)
wid.setLayout(vbox)
# ---
self.statusBar().showMessage("")
self.setGeometry(350, 300, 350, 150)
self.setWindowTitle('Timer')
self.setWindowIcon(QIcon('web.png'))
self.show()
def start_stop(self):
if self.state == TimerState.ACTIVE:
self.state = TimerState.INACTIVE
self.timer.stop()
self.sender().setText("Start")
self.split_button.setEnabled(False)
self.pause_button.setEnabled(False)
self.statusBar().showMessage("Timer stopped!")
elif self.state == TimerState.INACTIVE:
self.state = TimerState.ACTIVE
self.reset_timer()
self.begin_timer()
self.sender().setText("Stop")
self.split_button.setEnabled(True)
self.pause_button.setEnabled(True)
self.statusBar().showMessage("Timer started!")
elif self.state == TimerState.PAUSED:
self.sender().setText("Stop")
self.state = TimerState.ACTIVE
self.pause_button.setEnabled(True)
self.split_button.setEnabled(True)
self.begin_timer()
def pause_timer(self):
self.statusBar().showMessage("Paused!")
self.start_stop_button.setText("Start")
self.formatted_time.pause()
self.pause_button.setEnabled(False)
self.state = TimerState.PAUSED
self.timer.stop()
def split(self):
now = FormattedTime(self.formatted_time.minutes,
self.formatted_time.seconds,
self.formatted_time.centiseconds)
self.splits.append(now)
self.update_splits_table()
def update_current_time(self):
self.formatted_time.increment_time()
self.lcd.setDigitCount(len(self.formatted_time))
self.lcd.display(str(self.formatted_time))
def begin_timer(self):
self.timer.start(10)
self.timer.timeout.connect(self.update_current_time)
def update_splits_table(self):
row = 0
for split in self.splits:
self.item = QTableWidgetItem(str(split))
self.splits_table.setRowCount(len(self.splits))
self.splits_table.setItem(row, 0, self.item)
row = row + 1
pass
def reset_timer(self):
self.splits = []
self.splits_table.clear()
self.formatted_time = FormattedTime(0, 0, 0)
def quit_app(self):
sys.exit()
def center(self):
qr = self.frameGeometry()
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
self.statusBar().showMessage('Moved!')
def toggle_menu(self, state):
if state:
self.statusBar().show()
else:
self.statusBar().hide()
def closeEvent(self, event):
if self.state == TimerState.ACTIVE or self.state == TimerState.PAUSED:
reply = QMessageBox.question(
self, 'Message',
"Timer running. Are you sure you want to quit?",
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
event.accept() if reply == QMessageBox.Yes else event.ignore()
else:
event.accept()
def keyPressEvent(self, e):
if e.key() == Qt.Key_Space:
if self.state == TimerState.INACTIVE:
self.start_stop()
else:
self.pause_timer()
class DisplayCapteur(anr.Capteur, QWidget):
"""Une combinaison de Capteur et d'un QWidget"""
def __init__(self, parent_robot, nom, min_val, max_val, step=1, unite=None):
QWidget.__init__(self)
anr.Capteur.__init__(self, nom, min_val, max_val, step, unite)
self.parent_robot = parent_robot
self.backend = self.parent_robot.backend
self.updated_outside = False
self.ping = 0
# Création des widgets de l'équipement
self.gridlayout_eqp = QGridLayout(self)
self.spaceritem_equipement = QSpacerItem(1, 15)
self.label_name_equipement = QLabel()
self.label_message_equipement = QLabel("Dernière MAJ (s)")
self.lcdnumber_ping_eqp = QLCDNumber()
self.lcdnumber_eqp = QLCDNumber()
self.progressbar_eqp = QProgressBar()
# Configuration des widgets de l'équipement
self.ui_setup_equipement()
def ui_setup_equipement(self):
""" Configure l'ensemble des widgets de l'équipement"""
self.gridlayout_eqp.setAlignment(QT_TOP)
if self.unite == "None" or self.unite is None:
self.label_name_equipement.setText(self.nom)
else:
self.label_name_equipement.setText('{0} ({1})'.format(self.nom, self.unite))
self.gridlayout_eqp.addWidget(self.label_name_equipement, 0, 0, 1, 1, QT_LEFT)
self.label_message_equipement.setText("Dernière MAJ (s)")
self.gridlayout_eqp.addWidget(self.label_message_equipement, 2, 0, 1, 2, QT_LEFT)
self.lcdnumber_ping_eqp.setMaximumSize(QSize(75, 25))
self.lcdnumber_ping_eqp.setFixedSize(QLCD_SIZE2)
self.gridlayout_eqp.addWidget(self.lcdnumber_ping_eqp, 2, 1, 1, 1, QT_RIGHT)
if self.min_val is None or self.max_val is None or self.step is None:
self.lcdnumber_eqp.setMinimumSize(150, 30)
self.gridlayout_eqp.addWidget(self.lcdnumber_eqp, 0, 1, 1, 1, QT_RIGHT)
self.progressbar_eqp.hide()
else:
self.progressbar_eqp.setRange(int(self.min_val), int(self.max_val))
self.progressbar_eqp.setAlignment(QT_CENTER)
self.progressbar_eqp.setFormat("%v")
self.progressbar_eqp.setFixedSize(150, 30)
self.gridlayout_eqp.addWidget(self.progressbar_eqp, 0, 1, 1, 1, QT_RIGHT)
self.lcdnumber_eqp.hide()
#calcul et mise à jour du ping
def update_ping(self):
"""Mise à jour du ping de l'équipement"""
self.ping = round(abs(time.time() - self.last_updt), 1)
self.lcdnumber_ping_eqp.display(format(self.ping))
def set_state(self, valeur):
"""Change la valeur
Entrée:
- valeur (float)"""
anr.Binaire.set_state(self, valeur)
self.updated_outside = True
if self.valeur is not None:
self.lcdnumber_eqp.display(self.valeur)
self.progressbar_eqp.setValue(int(self.valeur))
self.updated_outside = False
class Calc(QWidget):
def __init__(self):
super().__init__()
self.stack = [0]
self.point = False
self.n_dec = 0
self.zeros = 0
self.modif = True
self.create_gui()
def create_gui(self):
self.setWindowTitle('Cracker calc')
calc_grid = QGridLayout(self)
self.screen = QLCDNumber(self)
self.screen.setMinimumSize(350, 45)
self.screen.setDigitCount(20)
calc_grid.addWidget(self.screen, 1, 0, 1, 4)
self.little_screen = QLCDNumber(self)
self.little_screen.setMaximumSize(175, 20)
self.little_screen.setDigitCount(20)
calc_grid.addWidget(self.little_screen, 0, 2, 1, 2)
labels = [
'C', 'CE', '√', 'x²', '7', '8', '9', '÷', '4', '5', '6', '×', '1',
'2', '3', '-', '0', '.', 'Ent', '+'
]
buttons = []
buttons_functions = [
lambda: self.reset(), lambda: self.add('CE'),
lambda: self.add('√'), lambda: self.add('x²'),
lambda: self.add('7'), lambda: self.add('8'),
lambda: self.add('9'), lambda: self.add('÷'),
lambda: self.add('4'), lambda: self.add('5'),
lambda: self.add('6'), lambda: self.add('×'),
lambda: self.add('1'), lambda: self.add('2'),
lambda: self.add('3'), lambda: self.add('-'),
lambda: self.add('0'), lambda: self.add('.'),
lambda: self.add('Ent'), lambda: self.add('+')
]
QShortcut(QKeySequence('Delete'),
self).activated.connect(buttons_functions[0])
QShortcut(QKeySequence('Backspace'),
self).activated.connect(buttons_functions[1])
QShortcut(QKeySequence('s'),
self).activated.connect(buttons_functions[2])
QShortcut(QKeySequence('²'),
self).activated.connect(buttons_functions[3])
QShortcut(QKeySequence('7'),
self).activated.connect(buttons_functions[4])
QShortcut(QKeySequence('8'),
self).activated.connect(buttons_functions[5])
QShortcut(QKeySequence('9'),
self).activated.connect(buttons_functions[6])
QShortcut(QKeySequence('/'),
self).activated.connect(buttons_functions[7])
QShortcut(QKeySequence('4'),
self).activated.connect(buttons_functions[8])
QShortcut(QKeySequence('5'),
self).activated.connect(buttons_functions[9])
QShortcut(QKeySequence('6'),
self).activated.connect(buttons_functions[10])
QShortcut(QKeySequence('*'),
self).activated.connect(buttons_functions[11])
QShortcut(QKeySequence('1'),
self).activated.connect(buttons_functions[12])
QShortcut(QKeySequence('2'),
self).activated.connect(buttons_functions[13])
QShortcut(QKeySequence('3'),
self).activated.connect(buttons_functions[14])
QShortcut(QKeySequence('-'),
self).activated.connect(buttons_functions[15])
QShortcut(QKeySequence('0'),
self).activated.connect(buttons_functions[16])
QShortcut(QKeySequence('.'),
self).activated.connect(buttons_functions[17])
QShortcut(QKeySequence('Return'),
self).activated.connect(buttons_functions[18])
QShortcut(QKeySequence('+'),
self).activated.connect(buttons_functions[19])
for k in range(20):
buttons.append(QPushButton(labels[k]))
buttons[k].clicked.connect(buttons_functions[k])
calc_grid.addWidget(buttons[k], 2 + k // 4, k % 4)
self.display()
def add(self, c):
if c in '0123456789':
if not self.modif:
self.stack.append(0)
self.modif = True
self.addNumeral(int(c))
elif c == '.':
if not self.modif:
self.stack.append(0)
self.modif = True
self.point = True
elif c == 'CE' and self.modif:
self.stack[-1] = 0
self.point = False
self.zeros = 0
self.n_dec = 0
else:
self.point = False
self.zeros = 0
self.n_dec = 0
if c == 'Ent':
self.modif = True
self.stack.append(0)
elif c in ('√', 'x²'):
if c == '√' and self.stack[-1] >= 0:
self.stack[-1] = math.sqrt(self.stack[-1])
self.modif = False
else:
self.stack[-1] = self.stack[-1]**2
self.modif = False
elif c in '+-×÷':
if len(self.stack) >= 2:
if c == '+':
self.stack[-2] = self.stack[-2] + self.stack[-1]
del self.stack[-1]
self.modif = False
elif c == '-':
self.stack[-2] = self.stack[-2] - self.stack[-1]
del self.stack[-1]
self.modif = False
elif c == '×':
self.stack[-2] = self.stack[-2] * self.stack[-1]
del self.stack[-1]
self.modif = False
elif self.stack[-1] != 0:
self.stack[-2] = self.stack[-2] / self.stack[-1]
del self.stack[-1]
self.modif = False
self.display()
def addNumeral(self, n):
if self.point:
self.n_dec += 1
if n != 0:
self.stack[-1] += n / 10**self.n_dec
self.zeros = 0
else:
self.zeros += 1
else:
self.stack[-1] = self.stack[-1] * 10 + n
def display(self):
if self.point and self.stack[-1] == int(self.stack[-1]):
self.screen.display(str(self.stack[-1]) + '.' + self.zeros * '0')
else:
self.screen.display(str(self.stack[-1]) + self.zeros * '0')
if len(self.stack) > 1:
self.little_screen.display(self.stack[-2])
else:
self.little_screen.display("")
def reset(self):
self.stack = [0]
self.point = False
self.n_dec = 0
self.zeros = 0
self.modif = True
self.display()
class SinglePlayerGame(QWidget):
def __init__(self, difficulty=1, numberOfGames=1):
super(SinglePlayerGame, self).__init__()
self.difficulty = difficulty
self.numberOfGames = numberOfGames
self.gamesPlayed = 0
self.playerScore = 0
self.opponentScore = 0
self.playerIsNotFirst = False
self.gamesCounter = QLabel()
self.gamesCounter.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
self.updateGameCounter()
mainLayout = QVBoxLayout()
self.gameWidget = BotGame(self.getOpponent())
self.gameWidget.gameEnded.connect(self.updateScoreAndReset)
self.saveButton = QPushButton('Save series')
self.saveButton.clicked.connect(self.saveGame)
self.message = self.createLabel('')
self.message.hide()
mainLayout.addLayout(self.createScoreLayout())
mainLayout.addWidget(self.gameWidget)
mainLayout.addWidget(self.message)
pack = self.packInHStretch([self.gamesCounter, self.saveButton])
mainLayout.addLayout(pack)
self.setLayout(mainLayout)
def createScoreLayout(self):
self.playerScoreLcd = QLCDNumber(2)
self.playerScoreLcd.setSegmentStyle(QLCDNumber.Filled)
self.playerScoreLcd.setMinimumSize(75, 50)
self.playerScoreLcd.display(0)
self.opponentScoreLcd = QLCDNumber(2)
self.opponentScoreLcd.setSegmentStyle(QLCDNumber.Filled)
self.opponentScoreLcd.setMinimumSize(75, 50)
self.opponentScoreLcd.display(0)
layout = QHBoxLayout()
layout.addStretch(1)
layout.addWidget(self.createLabel('You: '))
layout.addWidget(self.playerScoreLcd)
layout.addStretch(1)
layout.addWidget(self.createLabel('Opponent: '))
layout.addWidget(self.opponentScoreLcd)
layout.addStretch(1)
return layout
def packInHStretch(self, widgets):
layout = QHBoxLayout()
layout.addStretch(1)
for widget in widgets:
layout.addWidget(widget)
layout.addStretch(1)
return layout
def displayMessage(self, message):
self.message.setText(message)
self.message.show()
self.repaint()
def hideMessage(self):
self.message.hide()
self.repaint()
def updateScoreAndReset(self):
self.gamesPlayed += 1
self.playerIsNotFirst = not self.playerIsNotFirst
result = self.gameWidget.board.state
message = ''
if result == game.boards.State.X_WON:
self.playerScore += 3
message = 'Congrats! You won the game!'
elif result == game.boards.State.O_WON:
self.opponentScore += 3
message = 'Sorry! You lost the game!'
elif result == game.boards.State.DRAW:
self.playerScore += 1
self.opponentScore += 1
message = 'The game ended in a draw!'
self.displayMessage(message)
self.playerScoreLcd.display(self.playerScore)
self.opponentScoreLcd.display(self.opponentScore)
if self.numberOfGames > self.gamesPlayed:
for i in range(3, 0, -1):
self.displayMessage(message + ' New game starting in ' +
str(i))
time.sleep(1)
self.hideMessage()
self.gameWidget.reset(self.playerIsNotFirst)
self.updateGameCounter()
else:
self.announceResult()
def announceResult(self):
if self.playerScore > self.opponentScore:
self.displayMessage('Congrats! You won the series!')
elif self.playerScore < self.opponentScore:
self.displayMessage('Sorry. You lost the series!')
else:
self.displayMessage('The series ended in a draw!')
def updateGameCounter(self):
self.gamesCounter.setText('Game ' + str(self.gamesPlayed + 1) +
' of ' + str(self.numberOfGames))
def createLabel(self, text):
lbl = QLabel(text)
lbl.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
font = QFont()
font.setPointSize(12)
lbl.setFont(font)
return lbl
def getOpponent(self):
return game.players.ai.select_bot(self.difficulty)
def saveGame(self):
if self.gamesPlayed == self.numberOfGames:
if self.gameWidget.board.state != game.boards.State.IN_PROGRESS:
self.displayMessage('Cannot save. The game has ended.')
return
filename = QFileDialog().getSaveFileName(self, 'Save game',
'untitledgame')
if not filename[0]:
return
self.displayMessage('Saving...')
with open(filename[0], 'wb') as handle:
pickle.dump(self.getConfiguration(), handle)
self.displayMessage('Saved!')
def getConfiguration(self):
return (self.difficulty,
self.numberOfGames,
self.gamesPlayed,
self.playerScore,
self.opponentScore,
self.playerIsNotFirst,
self.gameWidget.board)
def validateConfig(self, config):
if not isinstance(config, tuple):
return False
if len(config) != 7:
return False
if not isinstance(config[0], int) or config[0] not in range(1, 5):
return False
if not isinstance(config[1], int) or config[1] < 1:
return False
if not isinstance(config[2], int) or config[2] > config[1]:
return False
if not isinstance(config[3], int) or config[3] < 0:
return False
if not isinstance(config[4], int) or config[4] < 0:
return False
if not isinstance(config[5], bool):
return False
if not isinstance(config[6], game.boards.Macroboard):
return False
return True
def loadConfiguration(self, config):
if not self.validateConfig(config):
raise ValueError('Invalid configuration')
self.difficulty = config[0]
self.numberOfGames = config[1]
self.gamesPlayed = config[2]
self.playerScore = config[3]
self.opponentScore = config[4]
self.playerIsNotFirst = config[5]
self.gameWidget.loadBoard(config[6])
self.gameWidget.setSecondPlayer(self.getOpponent())
self.updateGameCounter()
self.playerScoreLcd.display(self.playerScore)
self.opponentScoreLcd.display(self.opponentScore)
class Board(QFrame):
def __init__(self):
super().__init__()
self.__num_y = 23
self.__num_x = 25
self.__time_step = 400
self.__initPara()
self.__initUI()
self.__initNet()
self.setFocusPolicy(Qt.StrongFocus)
# 初始化参数
def __initPara(self):
self.__score = 0
self.__level = 0
self.__timer = QBasicTimer()
self.__FACTOR = 4 / 5
self.__FACTOR_SCREEN = 0.6
self.__canvas_w = self.geometry().width() * self.__FACTOR
self.__canvas_h = self.geometry().height()
self.__szy = int(self.__canvas_h / self.__num_y)
self.__szx = int(self.__canvas_w / self.__num_x)
self.__gameOverFlag = False
self.__net = []
self.__mshape = Shape()
self.__block = Block(
1, 1, self.__mshape.name[random.randint(0, self.__mshape.num - 1)],
self.__mshape,
self.__mshape.color[random.randint(0, self.__mshape.num_col - 1)])
# 初始化网格列表
def __initNet(self):
self.__net = [[0 for j in range(self.__num_x - 1)]
for j in range(self.__num_y - 1)]
# 初始化界面
def __initUI(self):
hb1 = QHBoxLayout()
score_info_la = QLabel('Score: ')
self.__score_la = QLabel('0')
hb1.addWidget(score_info_la)
hb1.addWidget(self.__score_la)
hb1.addStretch(1)
hb2 = QHBoxLayout()
level_info_la = QLabel('Level: ')
self.__level_la = QLabel('0')
hb2.addWidget(level_info_la)
hb2.addWidget(self.__level_la)
hb2.addStretch(1)
self.__speed_la = QLabel()
self.__speed_la.setText(str((1010 - self.__time_step) / 10))
self.__speed_label = QLabel('Speed:')
self.__sd_slider = QSlider()
self.__sd_slider.setOrientation(Qt.Horizontal)
self.__sd_slider.setMaximum(1)
self.__sd_slider.setMaximum(100)
self.__sd_slider.setValue(int((1010 - self.__time_step) / 10))
self.__sd_slider.valueChanged.connect(self.__LineEdt)
hb3 = QHBoxLayout()
hb3.addWidget(self.__speed_label)
hb3.addWidget(self.__speed_la)
hb2.addStretch(1)
x_num_la = QLabel('X number:')
self.__x_num_la_show = QLabel()
self.__x_num_la_show.setText(str(self.__num_x - 1))
hb12 = QHBoxLayout()
hb12.addWidget(x_num_la)
hb12.addWidget(self.__x_num_la_show)
hb12.addStretch(1)
self.__x_num_sl = QSlider(Qt.Horizontal, self)
self.__x_num_sl.setMaximum(100)
self.__x_num_sl.setMinimum(1)
self.__x_num_sl.setValue(self.__num_x - 1)
self.__x_num_sl.valueChanged.connect(self.__setXNum)
y_num_la = QLabel('Y number:')
self.__y_num_la_show = QLabel()
self.__y_num_la_show.setText(str(self.__num_y - 1))
hb13 = QHBoxLayout()
hb13.addWidget(y_num_la)
hb13.addWidget(self.__y_num_la_show)
hb13.addStretch(1)
self.__y_num_sl = QSlider(Qt.Horizontal, self)
self.__y_num_sl.setMinimum(1)
self.__y_num_sl.setMaximum(100)
self.__y_num_sl.setValue(self.__num_y - 1)
self.__y_num_sl.valueChanged.connect(self.__setYNum)
self.__st_btn = QPushButton('Start')
self.__st_btn.setEnabled(True)
hb7 = QHBoxLayout()
hb7.addWidget(self.__st_btn)
hb7.addStretch(1)
self.__stop_btn = QPushButton('Stop')
self.__stop_btn.setEnabled(True)
hb8 = QHBoxLayout()
hb8.addWidget(self.__stop_btn)
hb8.addStretch(1)
self.__pause_btn = QPushButton('Pause')
self.__pause_btn.setEnabled(True)
hb9 = QHBoxLayout()
hb9.addWidget(self.__pause_btn)
hb9.addStretch(1)
self.__new_btn = QPushButton('New Game')
self.__new_btn.setEnabled(True)
hb10 = QHBoxLayout()
hb10.addWidget(self.__new_btn)
hb10.addStretch(1)
self.__exit_btn = QPushButton('Exit')
self.__exit_btn.setEnabled(True)
hb11 = QHBoxLayout()
hb11.addWidget(self.__exit_btn)
hb11.addStretch(1)
self.__new_btn.clicked.connect(self.__newGameBtnAction)
self.__st_btn.clicked.connect(self.__stBtnAction)
self.__stop_btn.clicked.connect(self.__stopBtnAction)
self.__pause_btn.clicked.connect(self.__pauseBtnAction)
self.__exit_btn.clicked.connect(self.close)
self.__lcd = QLCDNumber()
self.__lcd.setMinimumSize(100, 100)
hb4 = QHBoxLayout()
hb4.addWidget(self.__lcd)
hb4.addStretch(1)
vb = QVBoxLayout()
vb.addLayout(hb1)
vb.addLayout(hb2)
vb.addLayout(hb4)
vb.addStretch(1)
vb.addLayout(hb3)
vb.addWidget(self.__sd_slider)
vb.addLayout(hb7)
vb.addLayout(hb8)
vb.addLayout(hb9)
vb.addStretch(1)
vb.addLayout(hb12)
vb.addWidget(self.__x_num_sl)
vb.addLayout(hb13)
vb.addWidget(self.__y_num_sl)
vb.addLayout(hb10)
vb.addStretch(10)
vb.addLayout(hb11)
hb5 = QHBoxLayout()
hb5.addStretch(1)
hb5.addLayout(vb)
self.setLayout(hb5)
screen = QDesktopWidget().screenGeometry()
width = screen.width() * self.__FACTOR_SCREEN
height = screen.height() * self.__FACTOR_SCREEN
x0 = screen.width() * (1 - self.__FACTOR_SCREEN) / 2
y0 = screen.height() * (1 - self.__FACTOR_SCREEN) / 2
self.setGeometry(x0, y0, width, height)
self.__canva_w = self.geometry().width() * self.__FACTOR
self.__canva_h = self.geometry().height()
self.__szx = int(self.__canva_w / self.__num_x)
self.__szy = int(self.__canva_h / self.__num_y)
self.setWindowTitle("Russian Block")
self.setWindowIcon(QIcon('example.png'))
self.show()
# 绘制网格
def __drawNetGrid(self, qp):
pen = QPen(Qt.lightGray, 1, Qt.DashLine)
qp.setPen(pen)
for i in range(self.__num_y):
qp.drawLine(int(self.__szx / 2),
int(i * self.__szy + self.__szy / 2),
int(self.__num_x * self.__szx - self.__szx / 2),
int(i * self.__szy + self.__szy / 2))
for i in range(self.__num_x):
qp.drawLine(int(i * self.__szx + self.__szx / 2),
int(self.__szy / 2),
int(i * self.__szx + self.__szx / 2),
int(self.__num_y * self.__szy - self.__szy / 2))
# 提示Game Over
def __gameOver(self, qp, x, y):
pen = QPen(Qt.red)
qp.setPen(pen)
qp.setFont(QFont('Blackoak Std', 20))
qp.drawText(x, y, self.__canva_w / 2, self.__canva_h / 2, True,
'Game Over！')
# 类的自调用painter绘制函数
def paintEvent(self, e):
self.__canvas_w = self.geometry().width() * self.__FACTOR
self.__canvas_h = self.geometry().height()
self.__szx = int(self.__canvas_w / self.__num_x)
self.__szy = int(self.__canvas_h / self.__num_y)
qp = QPainter()
qp.begin(self)
self.__drawNetGrid(qp) # 绘制网格
# 绘制形状
for i, eles in enumerate(self.__net):
for j, ele in enumerate(eles):
if not ele == 0:
self.__drawRect(qp, j + 1, i + 1, self.__szx, self.__szy,
ele)
if self.__timer.isActive():
self.__drawBlock(qp, self.__block, self.__szx, self.__szy)
# game over
if self.__gameOverFlag:
self.__gameOverFlag = False
self.__gameOver(qp, self.__canva_w / 4, self.__canva_h / 2)
qp.end()
# timer
def timerEvent(self, e):
if self.__isNextPosEmpty(self.__block, 0, 1):
self.__moveBlock(0, 1)
else:
self.__refreshFullNet(self.__block)
for k, ele in enumerate(self.__net):
if 0 not in ele:
self.__score += 1
self.__level += int(self.__score / 10)
self.__update_score()
self.__update_level()
for i in range(k):
self.__net[k - i] = self.__net[k - 1 - i]
self.__net[0] = [0 for i in range(self.__num_x - 1)]
# 游戏结束
if sum([1 for ele in self.__net[0] if not ele == 0]) > 0:
self.stop()
self.__st_btn.setEnabled(False)
self.__pause_btn.setEnabled(False)
self.__stop_btn.setEnabled(False)
self.__gameOverFlag = True
else:
self.__block = self.__generateRandomBlock()
self.update()
# 键盘按键事件
def keyPressEvent(self, e):
key = e.key()
x, y = self.__block.getXY()
if key == Qt.Key_Left:
if (x > 1) & self.__isNextPosEmpty(self.__block, -1, 0):
self.__block.setXY(x - 1, y)
elif key == Qt.Key_Right:
if self.__isNextPosEmpty(self.__block, +1, 0):
self.__block.setXY(x + 1, y)
elif key == Qt.Key_Down:
if self.__isNextPosEmpty(self.__block, 0, 2):
self.__block.setXY(x, y + 2)
elif key == Qt.Key_Up:
block = Block(self.__block.getXY()[0],
self.__block.getXY()[1], self.__block.getShape(),
self.__mshape, self.__block.getColor())
block.rota90()
if (block.getDownBoun() > self.__num_y - 1) | (
block.getLeftBoun() < 1) | (block.getRightBoun() >
self.__num_x - 1):
pass
else:
self.__block.rota90()
elif key == Qt.Key_P:
if self.__timer.isActive():
self.stop()
else:
self.start()
self.update()
# 窗口大小改变自动调用事件
def resizeEvent(self, e):
self.update()
# 判占位列表是否空
def __isNextPosEmpty(self, block, step_x, step_y):
bot = block.getDownBoun()
right = block.getRightBoun()
if ((bot + step_y) > self.__num_y - 1) | ((step_x > 0) & (
(right + step_x) > self.__num_x - 1)):
return False
pos = block.getPos()
for p in pos:
if p[1] < 1:
pass
elif not self.__net[p[1] - 1 + step_y][p[0] - 1 + step_x] == 0:
return False
return True
# 更新占位列表
def __refreshFullNet(self, block):
for pos in block.getPos():
if (pos[0] < 1) | (pos[1] < 1) | (pos[0] > self.__num_x - 1) | (
pos[1] > self.__num_y - 1):
pass
self.__net[pos[1] - 1][pos[0] - 1] = block.getColor()
# 生成一个随机对象
def __generateRandomBlock(self):
num_sha = random.randint(0, self.__mshape.num - 1)
sha = self.__mshape.name[num_sha]
num_col = random.randint(0, self.__mshape.num_col - 1)
color = self.__mshape.color[num_col]
x = random.randint(1, self.__num_x)
block = Block(x, 1, sha, self.__mshape, color)
while block.getRightBoun() > (self.__num_x - 1):
x = random.randint(1, self.__num_x)
block = Block(x, 1, sha, self.__mshape, color)
return block
# 绘制方块
def __drawRect(self, qp, x, y, szx, szy, color):
x_loca = x * szx - szx / 2
y_loca = y * szy - szy / 2
# Brush
brush = QBrush(color)
brush.setStyle(Qt.SolidPattern)
qp.setBrush(brush)
qp.drawRect(x_loca, y_loca, szx, szy)
# Pen
pen = QPen(Qt.darkBlue, 2, Qt.SolidLine)
qp.setPen(pen)
qp.drawRect(x_loca, y_loca, szx, szy)
# 绘制特定形状
def __drawBlock(self, qp, block, szx, szy):
color = block.getColor()
pos = block.getPos()
x1 = pos[0][0]
y1 = pos[0][1]
x2 = pos[1][0]
y2 = pos[1][1]
x3 = pos[2][0]
y3 = pos[2][1]
x4 = pos[3][0]
y4 = pos[3][1]
self.__drawRect(qp, x1, y1, szx, szy, color)
self.__drawRect(qp, x2, y2, szx, szy, color)
self.__drawRect(qp, x3, y3, szx, szy, color)
self.__drawRect(qp, x4, y4, szx, szy, color)
# 移动
def __moveBlock(self, speed_x, speed_y):
self.__block.setXY(self.__block.getXY()[0] + speed_x,
self.__block.getXY()[1] + speed_y)
# 更新成绩
def __update_score(self):
self.__score_la.setText(str(self.__score))
self.__lcd.display(str(self.__score))
# 更新等级
def __update_level(self):
self.__level_la.setText(str(self.__level))
# 滑动条事件
def __LineEdt(self):
self.__speed_la.setText(str(self.__sd_slider.value()))
self.__time_step = 1010 - self.__sd_slider.value() * 10
if self.__stop_btn.isEnabled() & self.__pause_btn.isEnabled():
self.start()
# 设置Xnum
def __setXNum(self):
self.stop()
self.__st_btn.setEnabled(False)
self.__stop_btn.setEnabled(False)
self.__pause_btn.setEnabled(False)
self.__x_num_la_show.setText(str(self.__x_num_sl.value()))
self.__num_x = self.__x_num_sl.value()
# 设置Y Num
def __setYNum(self):
self.stop()
self.__st_btn.setEnabled(False)
self.__stop_btn.setEnabled(False)
self.__pause_btn.setEnabled(False)
self.__y_num_la_show.setText(str(self.__y_num_sl.value()))
self.__num_y = self.__y_num_sl.value()
# 开始按钮事件
def __stBtnAction(self):
if self.__timer.isActive():
pass
else:
self.__st_btn.setEnabled(False)
self.__stop_btn.setEnabled(True)
self.__pause_btn.setEnabled(True)
self.__timer.start(self.__time_step, self)
# 停止按钮事件
def __stopBtnAction(self):
if self.__timer.isActive():
self.__timer.stop()
self.__st_btn.setEnabled(False)
self.__pause_btn.setEnabled(False)
self.__stop_btn.setEnabled(False)
self.__timer.stop()
# 暂停按钮事件
def __pauseBtnAction(self):
if self.__timer.isActive():
self.__timer.stop()
self.__st_btn.setEnabled(True)
self.__pause_btn.setEnabled(False)
self.__stop_btn.setEnabled(True)
# 新游戏按钮事件
def __newGameBtnAction(self):
if self.__timer.isActive():
self.stop()
self.__initPara()
self.__initNet()
self.__st_btn.setEnabled(True)
self.__pause_btn.setEnabled(True)
self.__stop_btn.setEnabled(True)
self.update()
self.start()
# 启动时间循环时间
def start(self):
self.__timer.start(self.__time_step, self)
# 停止计时器
def stop(self):
self.__timer.stop()
class Calculator(QWidget):
def __init__(self):
super().__init__()
self.digitStack = []
# было ли нажато '='
self.isEqual = False
self.currentNumber = ''
# настройка приложения
self.setAppOptions()
def setAppOptions(self):
self.setWindowTitle("Cl!")
self.setWindowIcon(QIcon("calculator.ico"))
self.setMaximumSize(QSize(230, 200))
self.setLcdDisplay()
self.settingLayout()
def setLcdDisplay(self):
self.lcdDisplay = QLCDNumber(12)
self.lcdDisplay.setSegmentStyle(QLCDNumber.Flat)
self.lcdDisplay.setMinimumSize(150, 50)
def settingLayout(self):
layout = QGridLayout()
layout.addWidget(self.lcdDisplay, 0, 0, 1, 4)
layout.addWidget(self.createButton("CE"), 1, 3)
calcButtons = [['7', '8', '9', '/'], ['4', '5', '6', '*'],
['1', '2', '3', '-'], ['0', '.', '=', '+']]
[
layout.addWidget(self.createButton(calcButtons[i][j]), i + 2, j)
for i in range(0, 4) for j in range(0, 4)
]
self.setLayout(layout)
def createButton(self, buttonText):
pb = QPushButton(buttonText)
pb.setMinimumSize(40, 40)
pb.clicked.connect(self.onButtonClick)
return pb
@pyqtSlot()
def onButtonClick(self):
self.handleButton(self.sender().text())
def handleButton(self, pressedButtonText):
if pressedButtonText == "CE":
self.pressedCe()
elif pressedButtonText == ".":
self.pressedPoint()
elif pressedButtonText == "=":
self.pressedEqual()
elif pressedButtonText.isdigit():
self.pressedDigit(pressedButtonText)
# если операция
else:
self.pressedOperation(pressedButtonText)
def pressedCe(self, displayMessage='0'):
self.isEqual = False
self.digitStack.clear()
self.currentNumber = ""
self.lcdDisplay.display(displayMessage)
def pressedPoint(self):
# если было нажато "=" ранее
self.checkPressEquil()
self.currentNumber += '.' if self.currentNumber != "" else "0."
self.lcdDisplay.display(self.currentNumber)
def pressedEqual(self):
self.isEqual = True
if len(self.digitStack) < 2 or self.currentNumber == "":
return
self.makeReckoning()
def pressedDigit(self, pressedButtonText):
# если было нажато "=" ранее
self.checkPressEquil()
# в стеке не должно быть 2 числа подряд
if len(self.digitStack) == 1 and self.currentNumber == "":
self.digitStack.clear()
# не более 12 цифр
if len(self.currentNumber) >= 12:
return
self.currentNumber += pressedButtonText
self.lcdDisplay.display(self.currentNumber)
def pressedOperation(self, pressedButtonText):
self.isEqual = False
digitStackLength = len(self.digitStack)
if digitStackLength == 0:
if self.currentNumber != "":
self.digitStack.append(self.currentNumber)
self.digitStack.append(pressedButtonText)
self.currentNumber = ""
elif digitStackLength == 1:
self.digitStack.append(pressedButtonText)
elif digitStackLength == 2:
if self.currentNumber != "":
self.makeReckoning()
else:
self.digitStack.pop()
self.digitStack.append(pressedButtonText)
def calculate(self):
rightNum = float(self.digitStack.pop())
operation = self.digitStack.pop()
leftNum = float(self.digitStack.pop())
result = 0
if operation == "+":
result = leftNum + rightNum
elif operation == "-":
result = leftNum - rightNum
elif operation == "/":
result = leftNum / rightNum
elif operation == "*":
result = leftNum * rightNum
return result
def checkPressEquil(self):
# если было нажато "=" ранее
if self.isEqual:
self.digitStack.clear()
self.isEqual = False
def makeReckoning(self):
self.digitStack.append(self.currentNumber)
rez = self.calculate()
self.digitStack.clear()
# для длинных значений
if rez > 999999999999:
self.pressedCe('Error!')
return
self.digitStack.append(str(rez))
self.currentNumber = ""
self.lcdDisplay.display(rez)
class ApplicationWindow(QDialog):
def __init__(self, ):
super().__init__()
self.setupUi(self)
self.initUI()
self.setupSig()
self.setupTimer()
self.client = OpenPlcModbus()
def setupUi(self, Dialog):
self.verticalLayout = QVBoxLayout(Dialog)
self.hbox_btns = QHBoxLayout()
self.btn_on = QPushButton()
self.btn_on.setText("Turn On")
self.btn_off = QPushButton()
self.btn_off.setText("Turn Off")
self.hbox_btns.addWidget(self.btn_on)
self.hbox_btns.addWidget(self.btn_off)
self.verticalLayout.addLayout(self.hbox_btns)
self.hbox_motor = QHBoxLayout()
self.btn_motor = QPushButton()
self.btn_motor.setText("Motor OFF")
self.btn_motor.setStyleSheet("background-color : #ff94ab")
self.hbox_motor.addWidget(self.btn_motor)
self.verticalLayout.addLayout(self.hbox_motor)
self.lcd_reading = QLCDNumber(Dialog)
self.lcd_reading.setMinimumSize(QtCore.QSize(300, 100))
self.verticalLayout.addWidget(self.lcd_reading)
def initUI(self):
self.setFixedSize(330, 220)
self.setWindowTitle("PyQt pyModbus OpenPLC")
screen = QtWidgets.QDesktopWidget().screenGeometry()
size = self.geometry()
self.move((screen.width() - size.width()) / 2,
(screen.height() - size.height()) / 2)
def setupSig(self):
self.btn_on.clicked.connect(self.turn_on)
self.btn_off.clicked.connect(self.turn_off)
def setupTimer(self):
self.timer = QtCore.QTimer(self)
self.timer.setInterval(OPTIONS['update_time'])
self.timer.timeout.connect(self.update_reading)
self.timer.start()
def turn_on(self):
self.client.turn_on(1)
# let enough time for modbus signal to be processed by the plc
loop = QtCore.QEventLoop()
QtCore.QTimer.singleShot(OPTIONS['pb_delay'], loop.quit)
loop.exec_()
self.client.turn_on(0)
def turn_off(self):
self.client.turn_off(1)
# let enought time for modbus signal to be processed by the plc
loop = QtCore.QEventLoop()
QtCore.QTimer.singleShot(OPTIONS['pb_delay'], loop.quit)
loop.exec_()
self.client.turn_off(0)
def update_reading(self):
try:
counter = self.client.get_counter_value()
status = self.client.get_motor_status()
self.lcd_reading.display(str(counter))
if status:
self.btn_motor.setStyleSheet("background-color : #ccff90")
self.btn_motor.setText("Motor ON")
else:
self.btn_motor.setStyleSheet("background-color : #ff94ab")
self.btn_motor.setText("Motor OFF")
except:
pass
def closeEvent(self, event):
self.client.close()
self.timer.stop()
class SinglePlayerGame(QWidget):
def __init__(self, difficulty=1, numberOfGames=1):
super(SinglePlayerGame, self).__init__()
self.difficulty = difficulty
self.numberOfGames = numberOfGames
self.gamesPlayed = 0
self.playerScore = 0
self.opponentScore = 0
self.playerIsNotFirst = False
self.gamesCounter = QLabel()
self.gamesCounter.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
self.updateGameCounter()
mainLayout = QVBoxLayout()
self.gameWidget = BotGame(self.getOpponent())
self.gameWidget.gameEnded.connect(self.updateScoreAndReset)
self.saveButton = QPushButton('Save series')
self.saveButton.clicked.connect(self.saveGame)
self.message = self.createLabel('')
self.message.hide()
mainLayout.addLayout(self.createScoreLayout())
mainLayout.addWidget(self.gameWidget)
mainLayout.addWidget(self.message)
pack = self.packInHStretch([self.gamesCounter, self.saveButton])
mainLayout.addLayout(pack)
self.setLayout(mainLayout)
def createScoreLayout(self):
self.playerScoreLcd = QLCDNumber(2)
self.playerScoreLcd.setSegmentStyle(QLCDNumber.Filled)
self.playerScoreLcd.setMinimumSize(75, 50)
self.playerScoreLcd.display(0)
self.opponentScoreLcd = QLCDNumber(2)
self.opponentScoreLcd.setSegmentStyle(QLCDNumber.Filled)
self.opponentScoreLcd.setMinimumSize(75, 50)
self.opponentScoreLcd.display(0)
layout = QHBoxLayout()
layout.addStretch(1)
layout.addWidget(self.createLabel('You: '))
layout.addWidget(self.playerScoreLcd)
layout.addStretch(1)
layout.addWidget(self.createLabel('Opponent: '))
layout.addWidget(self.opponentScoreLcd)
layout.addStretch(1)
return layout
def packInHStretch(self, widgets):
layout = QHBoxLayout()
layout.addStretch(1)
for widget in widgets:
layout.addWidget(widget)
layout.addStretch(1)
return layout
def displayMessage(self, message):
self.message.setText(message)
self.message.show()
self.repaint()
def hideMessage(self):
self.message.hide()
self.repaint()
def updateScoreAndReset(self):
self.gamesPlayed += 1
self.playerIsNotFirst = not self.playerIsNotFirst
result = self.gameWidget.board.state
message = ''
if result == game.boards.State.X_WON:
self.playerScore += 3
message = 'Congrats! You won the game!'
elif result == game.boards.State.O_WON:
self.opponentScore += 3
message = 'Sorry! You lost the game!'
elif result == game.boards.State.DRAW:
self.playerScore += 1
self.opponentScore += 1
message = 'The game ended in a draw!'
self.displayMessage(message)
self.playerScoreLcd.display(self.playerScore)
self.opponentScoreLcd.display(self.opponentScore)
if self.numberOfGames > self.gamesPlayed:
for i in range(3, 0, -1):
self.displayMessage(message + ' New game starting in ' +
str(i))
time.sleep(1)
self.hideMessage()
self.gameWidget.reset(self.playerIsNotFirst)
self.updateGameCounter()
else:
self.announceResult()
def announceResult(self):
if self.playerScore > self.opponentScore:
self.displayMessage('Congrats! You won the series!')
elif self.playerScore < self.opponentScore:
self.displayMessage('Sorry. You lost the series!')
else:
self.displayMessage('The series ended in a draw!')
def updateGameCounter(self):
self.gamesCounter.setText('Game ' + str(self.gamesPlayed + 1) +
' of ' + str(self.numberOfGames))
def createLabel(self, text):
lbl = QLabel(text)
lbl.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
font = QFont()
font.setPointSize(12)
lbl.setFont(font)
return lbl
def getOpponent(self):
return game.players.ai.select_bot(self.difficulty)
def saveGame(self):
if self.gamesPlayed == self.numberOfGames:
if self.gameWidget.board.state != game.boards.State.IN_PROGRESS:
self.displayMessage('Cannot save. The game has ended.')
return
filename = QFileDialog().getSaveFileName(self, 'Save game',
'untitledgame')
if not filename[0]:
return
self.displayMessage('Saving...')
with open(filename[0], 'wb') as handle:
pickle.dump(self.getConfiguration(), handle)
self.displayMessage('Saved!')
def getConfiguration(self):
return (self.difficulty, self.numberOfGames, self.gamesPlayed,
self.playerScore, self.opponentScore, self.playerIsNotFirst,
self.gameWidget.board)
def validateConfig(self, config):
if not isinstance(config, tuple):
return False
if len(config) != 7:
return False
if not isinstance(config[0], int) or config[0] not in range(1, 5):
return False
if not isinstance(config[1], int) or config[1] < 1:
return False
if not isinstance(config[2], int) or config[2] > config[1]:
return False
if not isinstance(config[3], int) or config[3] < 0:
return False
if not isinstance(config[4], int) or config[4] < 0:
return False
if not isinstance(config[5], bool):
return False
if not isinstance(config[6], game.boards.Macroboard):
return False
return True
def loadConfiguration(self, config):
if not self.validateConfig(config):
raise ValueError('Invalid configuration')
self.difficulty = config[0]
self.numberOfGames = config[1]
self.gamesPlayed = config[2]
self.playerScore = config[3]
self.opponentScore = config[4]
self.playerIsNotFirst = config[5]
self.gameWidget.loadBoard(config[6])
self.gameWidget.setSecondPlayer(self.getOpponent())
self.updateGameCounter()
self.playerScoreLcd.display(self.playerScore)
self.opponentScoreLcd.display(self.opponentScore)
class SettingsInterface:
def __init__(self, variable, signals):
self.signals = signals
self.create_interface(variable)
def create_interface(self, variable):
self.__setting_box = QHBoxLayout()
self.__setting_box.addWidget(QLabel("Settings:"))
self.__setting_box.addWidget(QLabel('N='))
self.__setting_box.addWidget(variable['n'])
self.__setting_box.addWidget(QLabel('M='))
self.__setting_box.addWidget(variable['m'])
self.__setting_box.addWidget(QLabel('Mines='))
self.__setting_box.addWidget(variable['mines'])
self.__setting_box.addWidget(variable['ok_button'])
self.__setting_box.addWidget(variable['pause_button'])
self.__statistics_box = QHBoxLayout()
self.time_display = QLCDNumber()
self.time_display.setFrameShape(QFrame.NoFrame)
self.time_display.setMaximumSize(80, 40)
self.time_display.setMinimumSize(80, 40)
self.bombs_display = QLCDNumber()
self.bombs_display.setMaximumSize(80, 40)
self.bombs_display.setMinimumSize(80, 40)
self.bombs_display.setFrameShape(QFrame.NoFrame)
self.signals.update_time_display.connect(self.update_time)
self.signals.update_bombs_display.connect(self.update_bombs)
clock = QPushButton()
clock.setStyleSheet('border: none;')
clock.setIcon(QtGui.QIcon('../Images/clock.png'))
clock.setMaximumSize(40, 40)
clock.clicked.connect(self.paint_clock)
self.clock_click = False
bomb = QPushButton()
bomb.setStyleSheet('border: none;')
bomb.setIcon(QtGui.QIcon('../Images/bomb.png'))
bomb.setMaximumSize(40, 40)
bomb.clicked.connect(self.paint_bomb)
self.bomb_click = False
self.__statistics_box.addWidget(clock)
self.__statistics_box.addWidget(self.time_display)
self.__statistics_box.addWidget(bomb)
self.__statistics_box.addWidget(self.bombs_display)
def paint_clock(self):
if not self.clock_click:
self.clock_click = True
self.time_display.setStyleSheet('font-size: 12px;'
'font-family: Arial;color: rgb(255, 255, 255);'
'background-color: rgb(38,56,76);')
else:
self.clock_click = False
self.time_display.setStyleSheet(None)
def paint_bomb(self):
if not self.bomb_click:
self.bomb_click = True
self.bombs_display.setStyleSheet('font-size: 12px;'
'font-family: Arial;color: rgb(255, 255, 255);'
'background-color: rgb(38,56,76);')
else:
self.bomb_click = False
self.bombs_display.setStyleSheet(None)
def update_time(self):
self.time_display.display(globals.time)
def update_bombs(self):
self.bombs_display.display(globals.flag_bombs)
def layout(self):
frame = QFrame()
frame.setFrameShape(QFrame.StyledPanel)
self.__layout = QVBoxLayout()
self.__layout.addLayout(self.__setting_box)
self.__layout.addLayout(self.__statistics_box)
self.__layout.addStretch(1)
self.__layout.setSpacing(10)
frame.setLayout(self.__layout)
frame.setMaximumSize(560, 126)
layout = QVBoxLayout()
layout.addWidget(frame)
return layout
class Pomodoro(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.initUI()
def initUI(self):
self.content = QWidget(self)
self.control = QGridLayout(self)
self.taskDur = QLineEdit(self)
self.taskDur.setText("40")
self.task = QLineEdit(self)
self.task.setText("task")
self.lcd = QLCDNumber(self)
self.lcd.display("00:00")
self.lcd.setMinimumSize(400, 400)
self.indicator = QLCDNumber()
self.indicator.display("00:00")
self.indicator.setMinimumSize(75, 55)
self.pat = PauseableTimer(self.lcd, self.task, self.indicator)
self.start = QPushButton(self)
self.start.setText("start")
self.start.released.connect(self.pat.start_)
self.pause = QPushButton(self)
self.pause.setText("pause")
self.pause.released.connect(self.pat.pause)
self.stop = QPushButton(self)
self.stop.setText("stop")
self.stop.released.connect(self.pat.stop_)
self.setTL = QPushButton(self)
self.setTL.setText("set dur,minutes")
self.setTL.released.connect(
lambda: self.pat.setCount(int(self.taskDur.text())))
self.log = QLineEdit(self)
self.append = QPushButton(self)
self.append.setText("append")
self.append.released.connect(
lambda: logging.critical("------" + self.log.text()))
self.control.addWidget(self.taskDur, 0, 0, Qt.AlignLeft)
self.control.addWidget(self.task, 0, 1, 1, 3) #从0,1位置开始,跨1行,跨3列
self.control.addWidget(self.lcd, 1, 0, 1, 4)
self.control.addWidget(self.start, 2, 0)
self.control.addWidget(self.pause, 2, 1)
self.control.addWidget(self.stop, 2, 2)
self.control.addWidget(self.setTL, 2, 3)
self.control.addWidget(self.log, 3, 0, 1, 3)
self.control.addWidget(self.append, 3, 3)
self.content.setLayout(self.control)
self.content.resize(400, 600)
self.setCentralWidget(self.content)
self.show()
frameGm = self.indicator.frameGeometry()
screen = QApplication.desktop().screenNumber(
QApplication.desktop().cursor().pos())
bottomRight = QApplication.desktop().screenGeometry(
screen).bottomRight()
frameGm.moveCenter(bottomRight)
self.indicator.move(frameGm.bottomRight())
self.indicator.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint)
self.indicator.show()
