def load(self, source):
"""Load anything that QImageReader or QMovie constructors accept"""
# Use QImageReader to identify animated GIFs for separate handling
# (Thanks to https://stackoverflow.com/a/20674469/435253 for this)
image_reader = QImageReader(source)
from PyQt5.QtGui import QImageIOHandler
if image_reader.supportsAnimation() and image_reader.imageCount() > 1:
movie = QMovie(source)
# Calculate the aspect ratio and adjust the widget size
movie.jumpToFrame(0)
movie_size = movie.currentImage().size()
self.movie_aspect = movie_size.width() / movie_size.height()
self.resizeEvent()
self.label.setMovie(movie)
movie.start()
# Free memory if the previous image was non-animated
self.orig_pixmap = None
else:
self.orig_pixmap = QPixmap(image_reader.read())
self.label.setPixmap(self.orig_pixmap)
# Fail quickly if our violated invariants result in stale
# aspect-ratio information getting reused
self.movie_aspect = None
# Keep the image from preventing downscaling
self.setMinimumSize(1, 1)
def _load_movie(self, movie: QMovie, reload_only: bool) -> None:
"""Load new movie into the graphics scene."""
movie.jumpToFrame(0)
if api.settings.image.autoplay.value:
movie.start()
widget = QLabel()
widget.setMovie(movie)
self._update_scene(widget, QRectF(movie.currentPixmap().rect()),
reload_only)
class IntroOverlay(_OverlayWidget):
opaque_timer = QtCore.QTimer()
opaque_timer.setSingleShot(True)
finished_signal = QtCore.pyqtSignal()
def __init__(self, parent):
super(IntroOverlay, self).__init__(parent)
self.parent = parent
self.intro_mov = QMovie(':/anim/Introduction.gif')
self.intro_mov.setCacheMode(QMovie.CacheAll)
self.intro_mov.finished.connect(self.finished)
self.opaque_timer.timeout.connect(self.set_opaque_for_mouse_events)
self.installEventFilter(self)
def eventFilter(self, obj, event):
if obj is None or event is None:
return False
if obj is self:
if event.type() == QtCore.QEvent.MouseButtonPress:
self.mouse_click()
return True
return False
def set_opaque_for_mouse_events(self):
self.setAttribute(QtCore.Qt.WA_TransparentForMouseEvents, False)
def intro(self):
LOGGER.info('Playing introduction in %sx %sy %spx %spx',
self.parent.rect().x(), self.parent.rect().y(),
self.parent.rect().width(), self.parent.rect().height())
self.movie_screen.setMovie(self.intro_mov)
self.movie_screen.setGeometry(self.parent.rect())
self._updateParent()
self.opaque_timer.start(1000)
self.movie_screen.show()
self.show()
self.intro_mov.jumpToFrame(0)
self.intro_mov.start()
def mouse_click(self):
self.intro_mov.stop()
self.finished()
def finished(self):
self.movie_screen.hide()
self.hide()
self.finished_signal.emit()
class _Loading(QSplashScreen):
"""A splashscreen to show while loading TensorFlow."""
def __init__(self):
"""Class constructor. Loads a gif to show while loading."""
path = os.path.join('res', 'loading', 'loading.gif')
self._gif = QMovie(path)
self._gif.jumpToFrame(0)
super().__init__(self._gif.currentPixmap(), Qt.WindowStaysOnTopHint)
self.showMessage('Loading, please wait...', color=Qt.yellow)
self._gif.frameChanged.connect(self._update)
self.setFixedSize(self.pixmap().size())
self._gif.start()
self.show()
def mousePressEvent(self, event: QMouseEvent):
"""Override the method so the splashscreen won't go away by clicking."""
def _update(self):
self.setPixmap(self._gif.currentPixmap())
class Pomodoro():
def __init__(self):
self.timer = 0
self.progress_value = 0
self.running = False
self.cycles = 0
self.state = STATE.WORK
self.beep = AudioSegment.from_mp3("pomodoro.mp3")
def swap_state(self):
if self.state == STATE.WORK:
self.state = STATE.PAUSE
else:
self.state = STATE.WORK
self.cycles += 1
self.set_cycles()
def swap(self):
self.swap_state()
self.state_label.setText(STATE_LABELS[self.state])
self.timer = 0
play(self.beep)
def reset(self):
self.timer = 0
self.change_progress_bar()
self.change_time_label()
def toggle(self):
if self.running:
self.toggle_button.setText('Play')
self.running = False
self.loop_stopper.set()
self.movie.stop()
else:
self.toggle_button.setText('Pause')
self.running = True
self.run()
self.movie.start()
def set_cycles(self):
self.cycles_label.setText('{} cycles'.format(self.cycles))
def run(self):
self.loop_stopper = threading.Event()
self.window.loop_stopper = self.loop_stopper
self.loop = threading.Thread(target=self.clock_loop,
args=(self.loop_stopper, ))
self.loop.start()
def change_progress_bar(self):
new_progress_value = int(self.timer / CYCLE_LENGTHS[self.state] * 100)
if new_progress_value != self.progress_value:
self.progress_value = new_progress_value
self.progress.setValue(self.progress_value)
def change_time_label(self):
mins = self.timer // 60
secs = self.timer - mins * 60
total_mins = CYCLE_LENGTHS[self.state] // 60
total_secs = CYCLE_LENGTHS[self.state] - total_mins * 60
new_time_label = "{:02d}:{:02d} / {:02d}:{:02d}".format(
mins, secs, total_mins, total_secs)
self.time_label.setText(new_time_label)
def clock_loop(self, stopper):
while not stopper.isSet():
self.timer += 1
self.change_progress_bar()
self.change_time_label()
if self.timer == CYCLE_LENGTHS[self.state]:
self.swap()
time.sleep(1)
def exec(self):
self.app = QApplication([])
# button font
button_font = QtGui.QFont("Sans", 13, QtGui.QFont.Bold)
# toggle button
self.toggle_button = QPushButton('Start')
self.toggle_button.setCheckable(True)
self.toggle_button.clicked.connect(self.toggle)
self.toggle_button.setFont(button_font)
# reset button
self.reset_button = QPushButton('Reset')
self.reset_button.clicked.connect(self.reset)
self.reset_button.setFont(button_font)
# progress label
self.progress_label = QLabel()
self.movie = QMovie("spinner.gif")
self.progress_label.setMovie(self.movie)
self.progress_label.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.progress_label.setAlignment(Qt.AlignCenter)
# label
self.label = QLabel('Pomodoro timer')
self.pixmap = QPixmap('pomodoro.png')
self.label.setPixmap(self.pixmap)
# time label
self.time_label = QLabel('00:00 / 25:00')
self.time_label.setFont(button_font)
# cycles label
self.cycles_label = QLabel('0 cycles')
cycles_font = QtGui.QFont("Sans", 12, QtGui.QFont.Bold)
self.cycles_label.setFont(cycles_font)
# state label
state_font = QtGui.QFont("Sans", 18, QtGui.QFont.Bold)
self.state_label = QLabel(STATE_LABELS[self.state])
self.state_label.setFont(state_font)
# progressbar
self.progress = QProgressBar()
self.progress.setMaximum(100)
self.progress.setMinimum(0)
self.progress.setValue(0)
self.window = CloseableQWidget(self)
self.window.setGeometry(770, 440, 400, 200)
self.outer_vertical = QVBoxLayout()
self.inner_horizonal = QHBoxLayout()
self.buttons_vertical = QVBoxLayout()
self.slider_clock_layout = QHBoxLayout()
self.labels = QHBoxLayout()
self.outer_vertical.addLayout(self.inner_horizonal)
self.inner_horizonal.addWidget(self.label)
self.inner_horizonal.addLayout(self.buttons_vertical)
self.buttons_vertical.addWidget(self.toggle_button)
self.buttons_vertical.addWidget(self.reset_button)
self.slider_clock_layout.addWidget(self.progress)
self.slider_clock_layout.addWidget(self.time_label)
self.labels.addWidget(self.state_label)
self.labels.addWidget(self.cycles_label)
self.labels.addWidget(self.progress_label, alignment=Qt.AlignRight)
self.outer_vertical.addLayout(self.labels)
self.outer_vertical.addLayout(self.slider_clock_layout)
self.window.setLayout(self.outer_vertical)
self.window.show()
# gif options
self.movie.setCacheMode(QMovie.CacheAll)
self.progress_label.setMovie(self.movie)
self.movie.jumpToFrame(1)
self.movie.loopCount()
self.app.setStyle('Fusion')
sys.exit(self.app.exec_())
class MoviePlayer(QWidget):
def __init__(self, parent=None):
super(MoviePlayer, self).__init__(parent)
self.movie = QMovie(self)
self.movie.setCacheMode(QMovie.CacheAll)
self.movieLabel = QLabel("No movie loaded")
self.movieLabel.setAlignment(Qt.AlignCenter)
self.movieLabel.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
self.movieLabel.setBackgroundRole(QPalette.Dark)
self.movieLabel.setAutoFillBackground(True)
self.currentMovieDirectory = ''
self.createControls()
self.createButtons()
self.movie.frameChanged.connect(self.updateFrameSlider)
self.movie.stateChanged.connect(self.updateButtons)
self.fitCheckBox.clicked.connect(self.fitToWindow)
self.frameSlider.valueChanged.connect(self.goToFrame)
self.speedSpinBox.valueChanged.connect(self.movie.setSpeed)
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.movieLabel)
mainLayout.addLayout(self.controlsLayout)
mainLayout.addLayout(self.buttonsLayout)
self.setLayout(mainLayout)
self.updateFrameSlider()
self.updateButtons()
self.setWindowTitle("Movie Player")
self.resize(400, 400)
def open(self):
fileName, _ = QFileDialog.getOpenFileName(self, "Open a Movie",
self.currentMovieDirectory)
if fileName:
self.openFile(fileName)
def openFile(self, fileName):
self.currentMovieDirectory = QFileInfo(fileName).path()
self.movie.stop()
self.movieLabel.setMovie(self.movie)
self.movie.setFileName(fileName)
self.movie.start()
self.updateFrameSlider()
self.updateButtons()
def goToFrame(self, frame):
self.movie.jumpToFrame(frame)
def fitToWindow(self):
self.movieLabel.setScaledContents(self.fitCheckBox.isChecked())
def updateFrameSlider(self):
hasFrames = (self.movie.currentFrameNumber() >= 0)
if hasFrames:
if self.movie.frameCount() > 0:
self.frameSlider.setMaximum(self.movie.frameCount() - 1)
elif self.movie.currentFrameNumber() > self.frameSlider.maximum():
self.frameSlider.setMaximum(self.movie.currentFrameNumber())
self.frameSlider.setValue(self.movie.currentFrameNumber())
else:
self.frameSlider.setMaximum(0)
self.frameLabel.setEnabled(hasFrames)
self.frameSlider.setEnabled(hasFrames)
def updateButtons(self):
state = self.movie.state()
self.playButton.setEnabled(self.movie.isValid()
and self.movie.frameCount() != 1
and state == QMovie.NotRunning)
self.pauseButton.setEnabled(state != QMovie.NotRunning)
self.pauseButton.setChecked(state == QMovie.Paused)
self.stopButton.setEnabled(state != QMovie.NotRunning)
def createControls(self):
self.fitCheckBox = QCheckBox("Fit to Window")
self.frameLabel = QLabel("Current frame:")
self.frameSlider = QSlider(Qt.Horizontal)
self.frameSlider.setTickPosition(QSlider.TicksBelow)
self.frameSlider.setTickInterval(10)
speedLabel = QLabel("Speed:")
self.speedSpinBox = QSpinBox()
self.speedSpinBox.setRange(1, 9999)
self.speedSpinBox.setValue(100)
self.speedSpinBox.setSuffix("%")
self.controlsLayout = QGridLayout()
self.controlsLayout.addWidget(self.fitCheckBox, 0, 0, 1, 2)
self.controlsLayout.addWidget(self.frameLabel, 1, 0)
self.controlsLayout.addWidget(self.frameSlider, 1, 1, 1, 2)
self.controlsLayout.addWidget(speedLabel, 2, 0)
self.controlsLayout.addWidget(self.speedSpinBox, 2, 1)
def createButtons(self):
iconSize = QSize(36, 36)
openButton = QToolButton()
openButton.setIcon(self.style().standardIcon(
QStyle.SP_DialogOpenButton))
openButton.setIconSize(iconSize)
openButton.setToolTip("Open File")
openButton.clicked.connect(self.open)
self.playButton = QToolButton()
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.setIconSize(iconSize)
self.playButton.setToolTip("Play")
self.playButton.clicked.connect(self.movie.start)
self.pauseButton = QToolButton()
self.pauseButton.setCheckable(True)
self.pauseButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
self.pauseButton.setIconSize(iconSize)
self.pauseButton.setToolTip("Pause")
self.pauseButton.clicked.connect(self.movie.setPaused)
self.stopButton = QToolButton()
self.stopButton.setIcon(self.style().standardIcon(QStyle.SP_MediaStop))
self.stopButton.setIconSize(iconSize)
self.stopButton.setToolTip("Stop")
self.stopButton.clicked.connect(self.movie.stop)
quitButton = QToolButton()
quitButton.setIcon(self.style().standardIcon(
QStyle.SP_DialogCloseButton))
quitButton.setIconSize(iconSize)
quitButton.setToolTip("Quit")
quitButton.clicked.connect(self.close)
self.buttonsLayout = QHBoxLayout()
self.buttonsLayout.addStretch()
self.buttonsLayout.addWidget(openButton)
self.buttonsLayout.addWidget(self.playButton)
self.buttonsLayout.addWidget(self.pauseButton)
self.buttonsLayout.addWidget(self.stopButton)
self.buttonsLayout.addWidget(quitButton)
self.buttonsLayout.addStretch()
class Benek(Postac):
def __init__(self, layout, move_distance=100, *args):
super().__init__(layout, *args)
self.clocks = []
self.load_player_config()
self.set_player_geo()
self.setText("")
self.setPixmap(QtGui.QPixmap("images/skins/" + JsonConnector.get_from_config("skin") + ".png"))
self.setScaledContents(True) # odpowiada za pozwolenie na skalowanie grafik
self.move_distance = self.okno.gWidth / move_distance
self.can_shot = True
self.playing_sound = False
self.rtimer = QTimer()
self.clocks.append(self.rtimer)
self.rtimer.timeout.connect(self.ruch_prawo)
self.ltimer = QTimer()
self.clocks.append(self.ltimer)
self.ltimer.timeout.connect(self.ruch_lewo)
self.shot_block_timer = QTimer()
self.clocks.append(self.shot_block_timer)
self.shot_block_timer.timeout.connect(self.shot_accuracy_unblock)
self.make_move_animations()
self.make_reload_bar()
def load_player_config(self):
config = JsonConnector.get_from_config("shipConfig")
self.laser_penetrate = config["penetrate"]
self.ship_size = config["shipSize"]
self.fire_speed = config["fireSpeed"]
self.ammo_size = config["ammoSize"]
self.ammo_dist = config["ammoSpeed"]
def set_player_geo(self):
size = int(self.okno.gWidth/self.ship_size)
self.setGeometry(QtCore.QRect((self.okno.width() - size)/2, self.okno.height() - size, size, size))
def rusz_benek_prawo(self):
self.rtimer.start(15)
self.pg = int((self.okno.width() - self.okno.gWidth) / 2 + self.okno.gWidth) # prawa granica
self.x_ = self.geometry().x()
self.move_sound_start()
self.expand_anim_movie(self.lmove_anim)
def ruch_prawo(self):
if self.pg >= (self.x_ + self.width()): # zapezpiecza postać przed wyjściem poza okno
if (self.pg - (self.x_ + self.width())) < self.move_distance: # jeśli odległość od lewego krańca jest mniejsza od ruchu to zmienia pozycje benka na krańcową
self.x_ = self.pg - self.width()
else:
self.x_ += self.move_distance
geo = QtCore.QRect(self.x_, self.geometry().y(), self.geometry().width(), self.geometry().height())
self.setGeometry(geo)
def stop_rusz_benek_prawo(self):
self.rtimer.stop()
self.move_sound_stop()
self.collapse_anim_movie(self.lmove_anim)
def rusz_benek_lewo(self):
self.ltimer.start(15)
self.x_ = self.geometry().x()
self.lg = int((self.okno.width() - self.okno.gWidth) / 2) # lewa granica
self.move_sound_start()
self.expand_anim_movie(self.rmove_anim)
def ruch_lewo(self):
if self.x_ > self.lg: # zabezpiecza przed wyjściem benka poza ekran
if self.x_ - self.lg < self.move_distance: # jeśli benkowi brakuje mniej niż dystans ruchu to przyjmuje zerową pozycje
self.x_ = self.lg
else:
self.x_ -= self.move_distance
geo = QtCore.QRect(self.x_, self.geometry().y(), self.geometry().width(), self.geometry().height())
self.setGeometry(geo)
def stop_rusz_benek_lewo(self):
self.ltimer.stop()
self.move_sound_stop()
self.collapse_anim_movie(self.rmove_anim)
def shot(self): # tworzy nowy strzał
if self.can_shot:
x = SoundThread("shotLaser.wav")
x.start()
self.ui.centralwidget.close()
x = PlayerLaser(self.ui.centralwidget, cause_geo=self.geometry(), can_penetrate=self.laser_penetrate, bullet_width=self.ammo_size[0], bullet_height=self.ammo_size[1], bullet_distance=self.ammo_dist) # aby poprawnie dodać element do główneg widgetu należy go wyłączyć a następnie pokazać, czli zresetować
self.ui.centralwidget.show()
self.shot_accuracy_block()
def shot_accuracy_block(self):
self.can_shot = False
self.shot_block_timer.start(self.fire_speed)
self.movie.start()
def shot_accuracy_unblock(self):
self.can_shot = True
self.shot_block_timer.stop()
self.movie.stop()
self.movie.jumpToFrame(self.movie.frameCount()-1)
def move_sound_start(self):
if not self.playing_sound:
self.playing_sound = True
self.move_sound = SoundThread("shotEngineNoise.wav", loop=True)
self.clocks.append(self.move_sound)
self.move_sound.start()
def move_sound_stop(self):
if self.playing_sound and not (self.ltimer.isActive() or self.rtimer.isActive()):
self.move_sound.stop()
self.clocks.remove(self.move_sound)
self.playing_sound = False
def make_reload_bar(self):
self.reload_bar = QLabel(self)
self.reload_bar.setGeometry(QtCore.QRect(int(self.width()/6), 0, int(self.width()/6), int(self.height()/2)))
self.reload_bar.setText("aa")
self.reload_bar.setPixmap(QtGui.QPixmap("images/reloadBar.gif"))
self.reload_bar.setScaledContents(True)
self.movie = QMovie("images/reloadBar.gif", QByteArray(), self.reload_bar)
self.movie.setCacheMode(QMovie.CacheAll)
self.movie.setSpeed(100 * 1000 / self.fire_speed) # ustala tak prędkość aby pokrywała się z szybkostrzelnością
self.reload_bar.setMovie(self.movie)
self.movie.jumpToFrame(self.movie.frameCount()-1)
def make_move_animations(self):
self.lmove_lab = QLabel(self)
self.lmove_lab.setText("")
self.lmove_lab.setGeometry(QtCore.QRect(0, 0, int(self.width() / 3), self.height()))
self.lmove_lab.setScaledContents(True)
self.lmove_anim = QMovie("images/lPlayerMove.gif", QByteArray(), self.lmove_lab)
self.lmove_anim.setCacheMode(QMovie.CacheAll)
self.lmove_anim.setSpeed(7000)
self.lmove_lab.setMovie(self.lmove_anim)
self.lmove_anim.jumpToFrame(0)
self.rmove_lab = QLabel(self)
self.rmove_lab.setText("")
self.rmove_lab.setGeometry(QtCore.QRect(int(self.width() / 3*2), 0, int(self.width() / 3), self.height()))
self.rmove_lab.setScaledContents(True)
self.rmove_anim = QMovie("images/rPlayerMove.gif", QByteArray(), self.rmove_lab)
self.rmove_anim.setCacheMode(QMovie.CacheAll)
self.rmove_anim.setSpeed(7000)
self.rmove_lab.setMovie(self.rmove_anim)
self.rmove_anim.jumpToFrame(0)
self.rmove_anim.frameCount()
def expand_anim_movie(self, movie):
movie.jumpToFrame(int(movie.frameCount() / 2))
def collapse_anim_movie(self, movie):
movie.jumpToFrame(0)
class MoviePlayer(QWidget):
def __init__(self, parent=None):
super(MoviePlayer, self).__init__(parent)
self.movie = QMovie(self)
self.movie.setCacheMode(QMovie.CacheAll)
self.movieLabel = QLabel("No movie loaded")
self.movieLabel.setAlignment(Qt.AlignCenter)
self.movieLabel.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
self.movieLabel.setBackgroundRole(QPalette.Dark)
self.movieLabel.setAutoFillBackground(True)
self.currentMovieDirectory = ''
self.createControls()
self.createButtons()
self.movie.frameChanged.connect(self.updateFrameSlider)
self.movie.stateChanged.connect(self.updateButtons)
self.fitCheckBox.clicked.connect(self.fitToWindow)
self.frameSlider.valueChanged.connect(self.goToFrame)
self.speedSpinBox.valueChanged.connect(self.movie.setSpeed)
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.movieLabel)
mainLayout.addLayout(self.controlsLayout)
mainLayout.addLayout(self.buttonsLayout)
self.setLayout(mainLayout)
self.updateFrameSlider()
self.updateButtons()
self.setWindowTitle("Movie Player")
self.resize(400, 400)
def open(self):
fileName, _ = QFileDialog.getOpenFileName(self, "Open a Movie",
self.currentMovieDirectory)
if fileName:
self.openFile(fileName)
def openFile(self, fileName):
self.currentMovieDirectory = QFileInfo(fileName).path()
self.movie.stop()
self.movieLabel.setMovie(self.movie)
self.movie.setFileName(fileName)
self.movie.start()
self.updateFrameSlider();
self.updateButtons();
def goToFrame(self, frame):
self.movie.jumpToFrame(frame)
def fitToWindow(self):
self.movieLabel.setScaledContents(self.fitCheckBox.isChecked())
def updateFrameSlider(self):
hasFrames = (self.movie.currentFrameNumber() >= 0)
if hasFrames:
if self.movie.frameCount() > 0:
self.frameSlider.setMaximum(self.movie.frameCount() - 1)
elif self.movie.currentFrameNumber() > self.frameSlider.maximum():
self.frameSlider.setMaximum(self.movie.currentFrameNumber())
self.frameSlider.setValue(self.movie.currentFrameNumber())
else:
self.frameSlider.setMaximum(0)
self.frameLabel.setEnabled(hasFrames)
self.frameSlider.setEnabled(hasFrames)
def updateButtons(self):
state = self.movie.state()
self.playButton.setEnabled(self.movie.isValid() and
self.movie.frameCount() != 1 and state == QMovie.NotRunning)
self.pauseButton.setEnabled(state != QMovie.NotRunning)
self.pauseButton.setChecked(state == QMovie.Paused)
self.stopButton.setEnabled(state != QMovie.NotRunning)
def createControls(self):
self.fitCheckBox = QCheckBox("Fit to Window")
self.frameLabel = QLabel("Current frame:")
self.frameSlider = QSlider(Qt.Horizontal)
self.frameSlider.setTickPosition(QSlider.TicksBelow)
self.frameSlider.setTickInterval(10)
speedLabel = QLabel("Speed:")
self.speedSpinBox = QSpinBox()
self.speedSpinBox.setRange(1, 9999)
self.speedSpinBox.setValue(100)
self.speedSpinBox.setSuffix("%")
self.controlsLayout = QGridLayout()
self.controlsLayout.addWidget(self.fitCheckBox, 0, 0, 1, 2)
self.controlsLayout.addWidget(self.frameLabel, 1, 0)
self.controlsLayout.addWidget(self.frameSlider, 1, 1, 1, 2)
self.controlsLayout.addWidget(speedLabel, 2, 0)
self.controlsLayout.addWidget(self.speedSpinBox, 2, 1)
def createButtons(self):
iconSize = QSize(36, 36)
openButton = QToolButton()
openButton.setIcon(self.style().standardIcon(QStyle.SP_DialogOpenButton))
openButton.setIconSize(iconSize)
openButton.setToolTip("Open File")
openButton.clicked.connect(self.open)
self.playButton = QToolButton()
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.setIconSize(iconSize)
self.playButton.setToolTip("Play")
self.playButton.clicked.connect(self.movie.start)
self.pauseButton = QToolButton()
self.pauseButton.setCheckable(True)
self.pauseButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPause))
self.pauseButton.setIconSize(iconSize)
self.pauseButton.setToolTip("Pause")
self.pauseButton.clicked.connect(self.movie.setPaused)
self.stopButton = QToolButton()
self.stopButton.setIcon(self.style().standardIcon(QStyle.SP_MediaStop))
self.stopButton.setIconSize(iconSize)
self.stopButton.setToolTip("Stop")
self.stopButton.clicked.connect(self.movie.stop)
quitButton = QToolButton()
quitButton.setIcon(self.style().standardIcon(QStyle.SP_DialogCloseButton))
quitButton.setIconSize(iconSize)
quitButton.setToolTip("Quit")
quitButton.clicked.connect(self.close)
self.buttonsLayout = QHBoxLayout()
self.buttonsLayout.addStretch()
self.buttonsLayout.addWidget(openButton)
self.buttonsLayout.addWidget(self.playButton)
self.buttonsLayout.addWidget(self.pauseButton)
self.buttonsLayout.addWidget(self.stopButton)
self.buttonsLayout.addWidget(quitButton)
self.buttonsLayout.addStretch()
class UiImageGroup(QLabel):
"""
:type iv_image: IVImage
:type self.movie: QMovie
"""
def __init__(self, iv_image):
super().__init__()
if not iv_image:
return
self.iv_image = iv_image
self.setContentsMargins(0, 0, 0, 0)
self.setStyleSheet("UiImageGroup { background-color: white; }")
self.setPixmap(QPixmap(str(self.iv_image.thumbnail_path)).scaled(imageviewer.settings.IMAGE_WIDTH,
imageviewer.settings.IMAGE_HEIGHT,
Qt.KeepAspectRatio))
self.movie = None
def gif(self):
if self.movie:
# Movie is already created
self.movie.start()
return
print("Creating movie for", str(self.iv_image.path))
self.movie = QMovie(str(self.iv_image.path))
image = QImage(str(self.iv_image.path))
if image.height() > imageviewer.settings.IMAGE_HEIGHT or image.width() > imageviewer.settings.IMAGE_WIDTH:
# scale the movie if it doesn't fit in the frame
# the frame is big enough we don't need the gif at full size to see what is going on
image2 = image.scaled(imageviewer.settings.IMAGE_WIDTH,
imageviewer.settings.IMAGE_HEIGHT,
Qt.KeepAspectRatio)
size = QSize()
size.setHeight(image2.height())
size.setWidth(image2.width())
self.movie.setScaledSize(size)
print("Scaled movie size")
self.setMovie(self.movie)
self.movie.start()
def open_explorer(self):
print(r'explorer /select,"' + str(self.iv_image.path) + '"')
subprocess.Popen(r'explorer /select,"' + str(self.iv_image.path) + '"')
def enterEvent(self, event):
if self.iv_image.filename.endswith(".gif"):
self.gif()
elif self.iv_image.filename.endswith(".jpg"):
self.setPixmap(QPixmap(str(self.iv_image.path)).scaled(imageviewer.settings.IMAGE_WIDTH,
imageviewer.settings.IMAGE_HEIGHT,
Qt.KeepAspectRatio))
QApplication.setOverrideCursor(Qt.PointingHandCursor)
event.accept()
def leaveEvent(self, event):
if self.movie:
self.movie.jumpToFrame(0) # Reset gif?
self.movie.stop()
QApplication.restoreOverrideCursor()
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
self.open_explorer()
event.accept()
def set_loading(self):
loader = QMovie(appctxt.get_resource("animations/loader.gif"))
self.preview_box.setMovie(loader)
loader.jumpToFrame(0)
self.preview_box.resize(loader.currentImage().size())
loader.start()
class Game(QMainWindow, Ui_MainWindow):
# set window on screen center
def center(self):
frameGm = self.frameGeometry()
screen = QtWidgets.QApplication.desktop().screenNumber(
QtWidgets.QApplication.desktop().cursor().pos())
centerPoint = QtWidgets.QApplication.desktop().screenGeometry(
screen).center()
frameGm.moveCenter(centerPoint)
self.move(frameGm.topLeft())
# move window by holding right mouse button
def mousePressEvent(self, event):
if event.buttons() == Qt.RightButton:
self.oldPos = event.globalPos()
def mouseMoveEvent(self, event):
# print(delta)
if event.buttons() == Qt.RightButton:
delta = QPoint(event.globalPos() - self.oldPos)
self.move(self.x() + delta.x(), self.y() + delta.y())
self.oldPos = event.globalPos()
def animateBackground(self):
# Load the file into a QMovie
self.movie = QMovie(APP_FOLDER + "/resources/images/clouds.gif",
QByteArray(), self)
self.movie.setScaledSize(QSize(1020, 900))
self.movie.setSpeed(70)
proxy_style = RoundPixmapStyle(radius=20,
style=self.lbBackground.style())
self.lbBackground.setStyle(proxy_style)
self.lbBackground.setMovie(self.movie)
self.movie.start()
def settings(self):
settings = QSettings()
return settings
def __init__(self, parent=None):
# Αρχικοποίηση του γραφικού περιβάλλοντος
super(Game, self).__init__(parent)
print(APP_FOLDER)
self.setupUi(self)
c.SCORE = self.settings().value("score", 0, type=int)
# Μεταβλητές
self.points = []
self.speed = 30
self.movie = None
self.commands = {
c.KEY_UP: logic.up,
c.KEY_DOWN: logic.down,
c.KEY_LEFT: logic.left,
c.KEY_RIGHT: logic.right,
c.KEY_UP_ALT: logic.up,
c.KEY_DOWN_ALT: logic.down,
c.KEY_LEFT_ALT: logic.left,
c.KEY_RIGHT_ALT: logic.right,
c.KEY_J: logic.left,
c.KEY_L: logic.right,
c.KEY_I: logic.up,
c.KEY_K: logic.down
}
self.setWindowFlags(QtCore.Qt.CustomizeWindowHint
| QtCore.Qt.FramelessWindowHint)
self.setAttribute(Qt.WA_TranslucentBackground, True)
self.center()
self.settings()
self.restoreStates()
self.fontDatabase = QFontDatabase()
self.fontDatabase.addApplicationFont(
APP_FOLDER + "/resources/fonts/JackportCollegeNcv-1MZe.ttf")
self.fontDatabase.addApplicationFont(
APP_FOLDER + "/resources/fonts/Rosemary-Bold.ttf")
self.lScore.setFont(QFont("JACKPORT COLLEGE NCV", 40))
self.lHiScore.setFont(QFont("JACKPORT COLLEGE NCV", 40))
self.bExit.setFont(QFont("JACKPORT COLLEGE NCV", 32))
self.lMediaSet.setFont(QFont("Rosemary", 38))
swipeCurImg = QPixmap(APP_FOLDER + "/resources/images/swipeCursor.png")
handCurImg = QPixmap(APP_FOLDER + "/resources/images/handCursor.png")
self.cursors = [handCurImg, swipeCurImg]
self.centralwidget.setCursor(QCursor(self.cursors[0], 15, 2))
self.frame.setCursor(QCursor(self.cursors[1], 35, 35))
self.frame.setAttribute(Qt.WA_StyledBackground, (True))
self.animateBackground()
self.musIcon()
self.sndIcon()
self.playMusic()
self.init_grid()
self.matrix = logic.new_game(c.GRID_LEN)
self.history_matrixs = []
self.update_grid_cells()
self.restoreGame()
# Αντιστοίχιση ενεργειών κίνησης ποντικιού και κλικ
self.bHelp.clicked.connect(self.bHelpClicked)
self.bAnim.clicked.connect(self.animStartStop)
self.sndslider.valueChanged.connect(self.sndslvalchanged)
self.musslider.valueChanged.connect(self.musslvalchanged)
self.frame.installEventFilter(self)
# Μέθοδος ενεργοποίησης/απενεργοποίησης του κινούμενου bakcground
def animStartStop(self):
if self.movie != None and self.movie.state() == QMovie.Running:
self.movie.stop()
self.bAnim.setStyleSheet(
"QPushButton{\n"
"border-image: url(:/resources/images/anim_off.png)\n"
"}")
else:
self.animateBackground()
self.bAnim.setStyleSheet(
"QPushButton{\n"
"border-image: url(:/resources/images/anim_on.png)\n"
"}")
# Σχεδίαση του βασικού πλαισίου
def init_grid(self):
for i in range(c.GRID_LEN):
for j in range(c.GRID_LEN):
self.gridBoard.addWidget(self.setTile("empty"), i, j)
def generate_next(self):
index = (gen(), gen())
while self.matrix[index[0]][index[1]] != 0:
index = (gen(), gen())
self.matrix[index[0]][index[1]] = 2
def update_grid_cells(self):
for i in range(c.GRID_LEN):
for j in range(c.GRID_LEN):
new_number = self.matrix[i][j]
if new_number == 0:
self.replaceTile("empty", i, j)
else:
self.replaceTile(new_number, i, j)
# Δημιουργία των αριθμητικών πλακιδίων
def setTile(self, item):
tile = QLabel('')
tile.setFocusPolicy(Qt.NoFocus)
tile.setFixedWidth(135)
tile.setFixedHeight(140)
path = c.CELL_IMAGE_DICT.get(item)
tile.setStyleSheet("QLabel{\n"
"border-image: url(:" + str(path) + ")\n"
"}")
tile.setObjectName(str(item))
return tile
# Μέθοδος αντικατάστασης πλακιδίου
def replaceTile(self, newTile, pX, pY):
item = self.gridBoard.itemAtPosition(pX, pY)
self.gridBoard.removeWidget(item.widget())
self.gridBoard.addWidget(self.setTile(newTile), pX, pY)
# Ενεργοποίηση των πλήκτρων χειρισμού
def keyPressEvent(self, event):
key = event.key()
modifiers = QtWidgets.QApplication.keyboardModifiers()
if modifiers == QtCore.Qt.ControlModifier:
if key == QtCore.Qt.Key_Home:
# print("is up!")
if self.frameGeometry().y() > 0:
self.move(self.frameGeometry().x(),
self.frameGeometry().y() - self.speed)
elif key == QtCore.Qt.Key_End:
# print("is down!")
if self.frameGeometry().y() > 0:
self.move(self.frameGeometry().x(),
self.frameGeometry().y() + self.speed)
elif key == QtCore.Qt.Key_Delete:
# print("is left!")
if self.frameGeometry().x() > 0:
self.move(self.frameGeometry().x() - self.speed,
self.frameGeometry().y())
elif key == QtCore.Qt.Key_PageDown:
# print("is right!")
if self.frameGeometry().x() > 0:
self.move(self.frameGeometry().x() + self.speed,
self.frameGeometry().y())
if key == c.KEY_BACK or key == c.KEY_BACK_ALT:
if len(self.history_matrixs) > 1:
self.matrix = self.history_matrixs.pop()
self.update_grid_cells()
#print('back on step total step:', len(self.history_matrixs))
# Έλεγχος Αν το παιχνίδι τελείωσε και αν έχει κερδηθεί ή χαθεί
elif key in self.commands:
self.frame.setCursor(Qt.BlankCursor)
self.matrix, done = self.commands[key](self.matrix)
if done:
self.stateOfGame()
def stateOfGame(self):
self.playSound(APP_FOLDER + c.SOUNDS_DICT["move"])
self.matrix = logic.add_two(self.matrix)
# record last move
self.history_matrixs.append(self.matrix)
#print(self.history_matrixs[-1])
self.update_grid_cells()
if logic.game_state(self.matrix) == 'win':
if logic.winNum != 65535:
print("num: " + str(logic.winNum))
for key, value in c.SOUNDS_DICT.items():
if key == str(logic.winNum):
self.playSound(APP_FOLDER + value)
winLooseDlg.WinLooseDialog(self).dialogTypes("WIN")
print("Κερδίσες")
else:
winLooseDlg.WinLooseDialog(self).dialogTypes("ENDGAME")
if logic.game_state(self.matrix) == 'lose':
self.playSound(APP_FOLDER + c.SOUNDS_DICT["lose"])
winLooseDlg.WinLooseDialog(self).dialogTypes("LOOSE")
print("Έχασες")
self.lScore.setText(str(c.SCORE))
if int(self.lHiScore.text()) < int(self.lScore.text()):
self.lHiScore.setText(self.lScore.text())
# Μέθοδος για χειρσμό με κλικ και σύρσιμο του ποντικιού
def eventFilter(self, source, event):
if event.type() == QtCore.QEvent.MouseMove:
self.frame.setCursor(QCursor(self.cursors[1], 35, 35))
if event.buttons() == QtCore.Qt.LeftButton:
if len(self.points) > 2:
startx, starty = self.points[0][0], self.points[0][1]
for i in range(len(self.points)):
self.points[i] = (self.points[i][0] - startx,
self.points[i][1] - starty)
self.points.append(
(event.localPos().x(), event.localPos().y()))
# print(self.points)
if event.type() == QtCore.QEvent.MouseButtonRelease and event.button(
) == QtCore.Qt.LeftButton:
# print("Released!")
self.mouseDown = False
strokes = moosegesture.getGesture(self.points)
if len(strokes) > 0:
strokeText = str(strokes[-1])
# print(strokeText)
if strokeText == "R":
self.matrix, done = logic.right(self.matrix)
if done:
self.stateOfGame()
elif strokeText == "L":
self.matrix, done = logic.left(self.matrix)
if done:
self.stateOfGame()
elif strokeText == "U":
self.matrix, done = logic.up(self.matrix)
if done:
self.stateOfGame()
elif strokeText == "D":
self.matrix, done = logic.down(self.matrix)
if done:
self.stateOfGame()
strokes.clear()
else:
return True
return self.frame.eventFilter(source, event)
# Μέθοδος για την αναπαραγωγή των ήχων
def playSound(self, sound):
pygame.mixer.pre_init(frequency=44100,
size=-16,
channels=3,
buffer=512)
pygame.mixer.init()
effect = pygame.mixer.Sound(sound)
self.sndslider.setMinimum(0)
self.sndslider.setMaximum(100)
vol = self.sndslider.value()
effect.set_volume(vol / 100)
pygame.mixer.find_channel().play(effect)
# Έλεγχος για αλλαγές στο εικονίδιο ήχου
def sndslvalchanged(self):
self.sndIcon()
# Αλλαγή του εικονιδίου ήχου
def sndIcon(self):
if self.sndslider.value() == 0:
self.lSound.setStyleSheet(
"QLabel{\n"
"border-image: url(:/resources/images/sound_off.png)\n"
"}")
else:
self.lSound.setStyleSheet(
"QLabel{\n"
"border-image: url(:/resources/images/sound_on.png)\n"
"}")
# Μέθοδος για την αnaπαραγωγή μουσικής
def playMusic(self):
pygame.mixer.init(frequency=44100, size=-16, channels=1, buffer=512)
pygame.mixer.music.load(
os.path.join(APP_FOLDER, "resources/sounds/backmusic.ogg"))
self.musslider.setMinimum(0)
self.musslider.setMaximum(100)
musvol = self.musslider.value()
pygame.mixer.music.set_volume(musvol / 100)
pygame.mixer.music.play(loops=-1)
self.musslider.valueChanged.connect(self.musslvalchanged)
def musslvalchanged(self):
pygame.mixer.music.pause()
pygame.mixer.music.set_volume(self.musslider.value() / 100)
pygame.mixer.music.unpause()
self.musIcon()
def musIcon(self):
if self.musslider.value() == 0:
self.lMusic.setStyleSheet(
"QLabel{\n"
"border-image: url(:/resources/images/music_off.png)\n"
"}")
else:
self.lMusic.setStyleSheet(
"QLabel{\n"
"border-image: url(:/resources/images/music_on.png)\n"
"}")
def chkGrid(self):
if len(self.history_matrixs) != 0:
lst = self.history_matrixs[-1]
else:
lst = self.settings().value("gameState")
nums = []
for i in range(len(lst)):
for j in range(len(lst[0])):
if lst[i][j] != 0:
nums.append(lst[i][j])
print(nums)
return nums
def bHelpClicked(self):
helpDlg.HelpDialog(self).exec()
pyqtSlot()
def on_bPlay_clicked(self):
self.gridBoard.blockSignals(False)
self.init_grid()
c.SCORE = 0
self.lScore.setText(str(c.SCORE))
self.matrix = logic.new_game(c.GRID_LEN)
self.history_matrixs = []
self.update_grid_cells()
pyqtSlot()
def on_bExit_clicked(self):
self.saveStates()
self.movie.jumpToFrame(100)
if len(self.chkGrid()) > 2:
winLooseDlg.WinLooseDialog(self).dialogTypes("SAVEGAME")
sys.exit()
# αποθήκευση τιμών της εφαρμογής
def saveStates(self):
self.settings().setValue("slidervalue", self.sndslider.value())
self.settings().setValue("sliderMvalue", self.musslider.value())
self.settings().setValue("HighScore", self.lHiScore.text())
self.settings().setValue("geometry", self.saveGeometry())
self.settings().setValue("windowState", self.saveState())
self.settings().sync()
# Επαναφορά αποθηκευμένων τιμών από το preferencies.ini
def restoreStates(self):
self.sndslider.setValue(self.settings().value("slidervalue",
40,
type=int))
self.musslider.setValue(self.settings().value("sliderMvalue",
50,
type=int))
self.lHiScore.setText(self.settings().value("HighScore", "0"))
if not self.settings().value("geometry") == None:
self.restoreGeometry(self.settings().value("geometry"))
if not self.settings().value("windowState") == None:
self.restoreState(self.settings().value("windowState"))
def saveGame(self):
if len(self.history_matrixs) != 0:
self.settings().setValue("gameState", self.history_matrixs[-1])
self.settings().setValue("score", self.lScore.text())
def restoreGame(self):
self.matrix = self.settings().value("gameState",
logic.new_game(c.GRID_LEN))
maxNum = np.max(self.matrix)
if logic.winNum < (maxNum):
logic.winNum = maxNum * 2
print(logic.winNum)
self.update_grid_cells()
self.lScore.setText(self.settings().value("score", "0"))
def closeEvent(self, e):
self.saveStates()
