class FunDialogPlayer(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
# setGeometry(x_pos, y_pos, width, height)
self.setGeometry(200, 200, 400, 400)
self.setWindowTitle("QMovie to show animated gif")
# set up the movie screen on a label
self.movie_screen = QLabel()
# expand and center the label
self.movie_screen.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.movie_screen.setAlignment(Qt.AlignCenter)
main_layout = QVBoxLayout()
main_layout.addWidget(self.movie_screen)
self.setLayout(main_layout)
# use an animated gif file you have in the working folder
# or give the full file path
self.movie = QMovie("giphy.gif", QByteArray(), self)
self.movie.setCacheMode(QMovie.CacheAll)
self.movie.setSpeed(100)
self.movie_screen.setMovie(self.movie)
self.movie.start()
def start(self):
"""sart animnation"""
self.show()
self.movie.start()
def stop(self):
"""stop the animation"""
self.movie.stop()
self.hide()
class ImagePlayer(QWidget):
""" src: https://gist.github.com/Svenito/4000025 """
def __init__(self, filename, parent=None):
super().__init__(parent)
# Load the file into a QMovie
self.movie = QMovie(filename, QByteArray(), self)
size = self.movie.scaledSize()
self.setGeometry(200, 200, size.width(), size.height())
self.movie_screen = QLabel()
# Make label fit the gif
self.movie_screen.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.movie_screen.setAlignment(Qt.AlignCenter)
# Create the layout
main_layout = QVBoxLayout()
main_layout.addWidget(self.movie_screen)
self.setLayout(main_layout)
# Add the QMovie object to the label
self.movie.setCacheMode(QMovie.CacheAll)
self.movie.setSpeed(100)
self.movie_screen.setMovie(self.movie)
self.movie.loopCount = -1
self.movie.start()
def __init__(self, file_name, parent):
super().__init__(parent)
movie = QMovie(file_name)
super().setMovie(movie)
movie.setSpeed(speed)
self.move(81, 727)
movie.start()
def animationLabel(self, index, animationFile, speed=100):
"""
Public slot to set an animated icon.
@param index tab index (integer)
@param animationFile name of the file containing the animation (string)
@param speed animation speed of the icon in percent of the original
icon's speed (integer)
@return reference to the created label (QLabel)
"""
if index == -1:
return None
if hasattr(self.__tabBar, 'setTabButton'):
side = self.__freeSide()
animation = QLabel(self)
if animationFile and not animation.movie():
movie = QMovie(animationFile, QByteArray(), animation)
movie.setSpeed(speed)
animation.setMovie(movie)
movie.start()
self.__tabBar.setTabButton(index, side, None)
self.__tabBar.setTabButton(index, side, animation)
return animation
else:
return None
def updateSignal(self):
vCloud = 'https://digital-ies.de/wp-content/uploads'
movie = QMovie(
os.path.dirname(sys.argv[0]) + "/pics/loader.gif", QByteArray(),
self)
movie.setCacheMode(QMovie.CacheAll)
movie.setSpeed(100)
self.y.label_44.setMovie(movie)
x = threading.Thread(target=movie.start())
x.setDaemon(True)
x.start()
http = urllib3.PoolManager()
response = http.request(
'GET',
"https://digital-ies.de/wp-content/uploads/myActualVersion.txt")
data = response.data.decode('utf-8')
if str(data) != str(version):
y = threading.Thread(target=self.meinDownload, args=(vCloud, ))
y.setDaemon(True)
y.start()
while not os.path.exists(
os.path.dirname(sys.argv[0]) + "/setup.exe"):
QApplication.instance().processEvents()
time.sleep(5)
movie.stop()
self.y.label_44.setMovie(None)
self.y.pushButton_19.setVisible(True)
p2 = subprocess.Popen(
os.path.dirname(sys.argv[0]) + "/unins000.exe")
p2.wait()
subprocess.Popen(os.path.dirname(sys.argv[0]) + "/setup.exe")
os.system("taskkill /f /im LIMASCalc.exe")
class ImagePlayer(QWidget):
def __init__(self, filename, title, parent=None):
QWidget.__init__(self, parent)
# Load the file into a QMovie
self.movie = QMovie(filename, QByteArray(), self)
size = self.movie.scaledSize()
self.setGeometry(200, 200, size.width(), size.height())
self.setWindowTitle(title)
self.movie_screen = QLabel()
# Make label fit the gif
self.movie_screen.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.movie_screen.setAlignment(Qt.AlignCenter)
# Create the layout
main_layout = QVBoxLayout()
main_layout.addWidget(self.movie_screen)
self.setLayout(main_layout)
# Add the QMovie object to the label
self.movie.setCacheMode(QMovie.CacheAll)
self.movie.setSpeed(100)
self.movie_screen.setMovie(self.movie)
self.movie.start()
def animationLabel(self, index, animationFile, speed=100):
"""
Public slot to set an animated icon.
@param index tab index (integer)
@param animationFile name of the file containing the animation (string)
@param speed animation speed of the icon in percent of the original
icon's speed (integer)
@return reference to the created label (QLabel)
"""
if index == -1:
return None
if hasattr(self.__tabBar, 'setTabButton'):
side = self.__freeSide()
animation = QLabel(self)
if animationFile and not animation.movie():
movie = QMovie(animationFile, QByteArray(), animation)
movie.setSpeed(speed)
animation.setMovie(movie)
movie.start()
self.__tabBar.setTabButton(index, side, None)
self.__tabBar.setTabButton(index, side, animation)
return animation
else:
return None
class GifPlayer(QWidget):
def __init__(self, hsize, vsize, parent=None):
super(GifPlayer, self).__init__(parent)
# set size and title
self.resize(hsize, vsize)
self.setWindowTitle('Gif Viewer')
# create frame
# self.layout = QGridLayout()
self.frame = QFrame(self)
# self.frame.setLayout(self.layout)
# label for movie
self.gif_label = QLabel(self.frame)
self.gif_label.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.gif_label.setAlignment(Qt.AlignCenter)
# add stuff to layout
# self.layout.addWidget(self.gif_label, 0, 0, 1, 1)
# self.layout.setContentsMargins(1, 1, 1, 1)
# create actions / shortcuts
self.createActions()
# Load the file into a QMovie
# size = self.movie.scaledSize()
# self.setGeometry(200, 200, size.width(), size.height())
# self.setWindowTitle(title)
def load_gif(self, fileName):
self.gif = QMovie(fileName, QByteArray(), self.gif_label)
self.gif.setCacheMode(QMovie.CacheAll)
self.gif.setSpeed(100)
self.gif_label.setMovie(self.gif)
# gif_size = self.gif.scaledSize()
# print(gif_size)
# self.gif_asp_ratio =
# gif_size = self.gif.scaledSize()
# self.gif_label.setFixedHeight(gif_size.height())
# self.gif_label.setFixedWidth(gif_size.width())
self.gif.start()
# def fix_size(self):
# screen_size = self.geometry()
# gif_size = self.gif.scaledSize()
# print(screen_size)
# print(gif_size)
def createActions(self):
self.close_window_shortcut = QShortcut(QKeySequence("Ctrl+W"), self)
self.close_window_shortcut.activated.connect(self.close)
class Ui_MainWindow(object):
okno = None
def __init__(self):
self.tlo = QtWidgets.QLabel(
) # atrapy elementów tak aby nie powstawały błędy
self.player = QtWidgets.QLabel()
self.enemy = QtWidgets.QLabel()
self.score = QtWidgets.QLabel()
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
self.centralwidget = QtWidgets.QWidget(MainWindow)
self.centralwidget.setCursor(QtGui.QCursor(QtCore.Qt.CrossCursor))
self.centralwidget.setObjectName("centralwidget")
self.make_background()
self.make_score()
self.player = Benek(self.centralwidget)
self.centralwidget.close()
MainWindow.setCentralWidget(self.centralwidget)
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
_translate = QtCore.QCoreApplication.translate
MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow"))
self.score.setText(_translate("MainWindow", "Score: 0"))
def make_background(self):
self.tlo = QtWidgets.QLabel(self.centralwidget)
self.tlo.setGeometry(
QtCore.QRect(0, 0, self.okno.width(), self.okno.height()))
self.tlo.setText("")
self.tlo.setPixmap(QtGui.QPixmap("images/stars_background.gif"))
self.tlo.setScaledContents(True)
self.tlo.setObjectName("label")
self.movie = QMovie("images/stars_background.gif", QByteArray(),
self.tlo)
self.movie.setCacheMode(QMovie.CacheAll)
self.movie.setSpeed(100)
self.tlo.setMovie(self.movie)
self.movie.start()
self.movie.loopCount()
def make_score(self):
Postac.score = 0
self.score = QtWidgets.QLabel(self.centralwidget)
self.score.setGeometry(QtCore.QRect(0, 100, 261, 41))
font = QtGui.QFont()
font.setPointSize(24)
font.setBold(True)
self.score.setFont(font)
self.score.setText("Score: 0")
self.score.setObjectName("label_4")
self.score.setStyleSheet("QLabel#label_4 {color: #aaffff}")
def begin_search(self):
print("搜索开始")
self.label_search_gif = QLabel(self.navigation)
movie = QMovie("./resource/image/1.gif")
self.label_search_gif.setMovie(movie)
self.label_search_gif.setGeometry(160, 9, 16, 16)
self.label_search_gif.show()
movie.start()
movie.setSpeed(90)
self.label_search_state.setText("正在更新本地音乐列表...")
def open(self):
self.file = QFileDialog.getOpenFileName(self, "Open File", self.pwd)[0]
if self.file == "":
return
self.information = info.Information(self, self.file)
movie = QMovie(self.file, QByteArray(), self)
movie.setCacheMode(QMovie.CacheAll)
movie.setSpeed(100)
self.label.setMovie(movie)
movie.start()
def __makeAnimatedLabel(self, fileName, label):
"""
Private slot to create an animated label.
@param fileName name of the file containing the animation (string)
@param label reference to the label to be animated (QLabel)
"""
movie = QMovie(fileName, QByteArray(), label)
movie.setSpeed(100)
label.setMovie(movie)
movie.start()
def __makeAnimatedLabel(self, fileName, label):
"""
Private slot to create an animated label.
@param fileName name of the file containing the animation (string)
@param label reference to the label to be animated (QLabel)
"""
movie = QMovie(fileName, QByteArray(), label)
movie.setSpeed(100)
label.setMovie(movie)
movie.start()
def on_scan(self, state: int):
if state == 1:
self.label_search_gif = QLabel(self.navigation)
movie = QMovie(Const.res + "/image/1.gif")
self.label_search_gif.setMovie(movie)
self.label_search_gif.setGeometry(160, 9, 16, 16)
self.label_search_gif.show()
movie.start()
movie.setSpeed(90)
self.label_search_state.setText("正在更新本地音乐列表...")
else:
self.label_search_gif.hide()
self.label_search_state.setText("更新完成")
self.reload_local_musics()
class ImagePlayer(QWidget):
def __init__(self, filename, parent=None):
QWidget.__init__(self, parent)
self.movie = QMovie(filename) # load the file into a QMovie
self.movie_screen = QLabel()
self.movie_screen.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
main_layout = QVBoxLayout()
main_layout.addWidget(self.movie_screen)
self.setLayout(main_layout)
self.movie.setCacheMode(QMovie.CacheAll)
self.movie.setSpeed(100)
self.movie_screen.setMovie(self.movie)
self.movie.start()
class PopupExpulsar(QWidget):
"""
Popup mostrado al expulsar un jugador de la nave
"""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.image_size = (480, 270)
self.__init_ui()
self.__connect_events()
self.__retranslate_ui()
def __init_ui(self):
# Main widget declaration
self.gif_label = QLabel(self)
self.setMinimumSize(*(self.image_size))
# Text
self.text_label = QLabel(self)
# Add to layout
self.main_vertical_layout = QVBoxLayout(self)
self.main_vertical_layout.addStretch(1)
self.main_vertical_layout.addWidget(self.text_label)
self.main_vertical_layout.addStretch(3)
def __retranslate_ui(self):
self.setWindowTitle("DCCrew DemoCratiCa - Ejection")
# Text
self.text_label.setStyleSheet("""
color: white;
font-size: 28px;
""")
self.text_label.setFont(QFont("Helvetica"))
self.text_label.setAlignment(Qt.AlignCenter)
# Gif
path_gif = path.join("assets", "expulsado.gif")
self.gif = QMovie(path_gif)
self.gif.setSpeed(200)
self.gif.setScaledSize(QSize(*self.image_size))
self.gif_label.setMovie(self.gif)
self.gif_label.setMinimumSize(QSize(*(self.image_size)))
def __connect_events(self):
pass
def actualizar_label(self, username):
self.text_label.setText(f"{username} ha sido expulsado...")
self.gif.start()
def add_gif(self, data):
if data['error']:
self.gif_data_frame.show()
self.scroll.hide()
self.info_label.show()
return
row, col, error, file_name = data.values()
movie = QMovie(file_name)
movie.setSpeed(200)
label_gif = QLabel()
label_gif.setMovie(movie)
movie.start()
self.gifs_layout.addWidget(label_gif, row, col)
label_gif.show()
class MoviePlayer(QMainWindow):
def __init__(self, *args):
QMainWindow.__init__(self, *args)
# setGeometry(x_pos, y_pos, width, height)
self.setGeometry(200, 200, 400, 400)
self.setWindowTitle("QMovie to show animated gif")
# set up the movie screen on a label
self.movie_screen = QLabel()
# expand and center the label
self.movie_screen.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
#btn_start = QPushButton("Start Animation", self)
# btn_start.clicked.connect(self.start)
btn_stop = QPushButton("Stop Animation", self)
btn_stop.clicked.connect(self.stop)
main_layout = QVBoxLayout()
main_layout.addWidget(self.movie_screen)
# main_layout.addWidget(btn_start)
main_layout.addWidget(btn_stop)
self.setLayout(main_layout)
# use an animated gif file you have in the working folder
# or give the full file path
self.movie = QMovie("./AG_Dog.gif", QByteArray(), self)
self.movie.setCacheMode(QMovie.CacheAll)
self.movie.setSpeed(100)
self.movie_screen.setMovie(self.movie)
self.movie.start()
def start(self):
"""sart animnation"""
self.movie.start()
def stop(self):
"""stop the animation"""
self.movie.stop()
print(self.movie.fileName())
self.movie.start()
class Loading(QWidget, QMovie):
def __init__(self, parent=None):
super().__init__()
# setGeometry(x_pos, y_pos, width, height)
self.setGeometry(200, 200, 400, 400)
self.setWindowTitle("QMovie to show animated gif")
# set up the movie screen on a label
self.movie_screen = QLabel()
# expand and center the label
self.movie_screen.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.movie_screen.setAlignment(Qt.AlignCenter)
btn_start = QPushButton("Start Animation")
btn_start.clicked.connect(self.start)
btn_stop = QPushButton("Stop Animation")
btn_stop.clicked.connect(self.stop)
main_layout = QVBoxLayout()
main_layout.addWidget(self.movie_screen)
main_layout.addWidget(btn_start)
main_layout.addWidget(btn_stop)
self.setLayout(main_layout)
# use an animated gif file you have in the working folder
# or give the full file path
self.movie = QMovie("loading.gif", QByteArray(), self)
self.movie.setCacheMode(QMovie.CacheAll)
self.movie.setSpeed(100)
self.movie_screen.setMovie(self.movie)
timer = QTimer(self)
self.startAnimation()
timer.singleShot(3000, self.stopAnimation)
self.show()
def start(self):
"""sart animnation"""
self.movie.start()
def stop(self):
"""stop the animation"""
self.movie.stop()
def show_slides(self):
try:
i, img_object = self._result.get(True, 5)
if isinstance(img_object, QMediaContent):
self.MediaPlayer.setMedia(img_object)
except Empty:
self.timer.stop()
return
while i != self._next:
self._result.put((i, img_object), False)
i, img_object = self._result.get()
if isinstance(img_object, QMediaContent):
self.MediaPlayer.setMedia(img_object)
if isinstance(img_object, QMediaContent):
# If a movie
# self.MediaPlayer.setMedia(img_object)
self.layout.setCurrentWidget(self.VideoWidget)
self.MediaPlayer.play()
elif isinstance(img_object, QMovie):
# If a gif
size = img_object.scaledSize()
img_object = QMovie(img_object.fileName())
img_object.setCacheMode(QMovie.CacheAll)
self._gif = img_object
img_object.frameChanged.connect(self.gif_frame_changed)
self.SlideShowWidget.setMovie(img_object)
size.scale(self.SlideShowWidget.size(), Qt.KeepAspectRatio)
img_object.setScaledSize(size)
img_object.setSpeed(int(self.rate * 100))
self.layout.setCurrentWidget(self.SlideShowWidget)
# self.change_playspeed(self.rate)
img_object.start()
else:
# If a picture
# print(img_object.size())
self.SlideShowWidget.setPixmap(
img_object.scaled(self.SlideShowWidget.size(),
Qt.KeepAspectRatio))
self.timer.start(self.delay / self.rate)
self.layout.setCurrentWidget(self.SlideShowWidget)
self._next += 1
self.threading(self.maxqsize - self._result.qsize())
class LoadingScreen(QDialog):
def __init__(self, parent, file_path, text):
"""Initialise the loading screen
Arguments:
parent {QObject} -- The parent QObject
file_path {str} -- Path to file of loading GIF
text {str} -- Text to be shown on the loading screen
"""
super().__init__(parent)
self.file = file_path
self.text = text
self.setWindowFlag(Qt.FramelessWindowHint)
self.setFixedSize(200, 200)
self.setModal(True)
self.init_UI()
def init_UI(self):
"""Initialise the UI by loading the GIF and adding the text label
"""
vbox = QVBoxLayout()
vbox.setAlignment(Qt.AlignHCenter)
self.movie_screen = QLabel(self)
self.movie_screen.setFixedSize(50, 50)
self.movie = QMovie(self.file, QByteArray(), self)
self.movie.setScaledSize(self.movie_screen.size())
self.movie.setCacheMode(QMovie.CacheAll)
self.movie.setSpeed(100)
self.movie_screen.setMovie(self.movie)
self.movie.start()
self.movie.loopCount()
self.loading = QLabel(self.text)
self.loading.setAlignment(Qt.AlignCenter)
vbox.addStretch(2)
vbox.addWidget(self.movie_screen, Qt.AlignCenter)
vbox.addSpacing(10)
vbox.addWidget(self.loading, Qt.AlignHCenter)
vbox.addStretch(1)
self.setLayout(vbox)
def jugador_golpeado(self, vida):
# Movimiento
paso = (self.enemigo.x() - self.jugador.x() - 300) / 5
for _ in range(5):
self.enemigo.move(self.enemigo.x() - paso, self.enemigo.y())
self.sleep(0.04)
# Animacion
gif_combo = QMovie(self.rutas["enemigo_golpea"])
gif_combo.setSpeed(200)
self.enemigo.setMovie(gif_combo)
self.enemigo.setFixedSize(256 * 1.8, 188 * 1.8)
self.enemigo.move(self.enemigo.x() - 300, self.enemigo.y() - 100)
gif_combo.start()
self.sleep(2.2)
self.enemigo.move(self.enemigo.x() + 300, self.enemigo.y() + 100)
self.enemigo.setPixmap(QPixmap(self.rutas['enemigo']))
self.enemigo.setFixedSize(91.75 * 1.1, 187.5 * 1.1)
self.barra_vida_jugador.setValue(vida)
# Vuelta
for _ in range(5):
self.enemigo.move(self.enemigo.x() + paso, self.enemigo.y())
self.sleep(0.02)
def ShowGameReport(self):
# clear the right side of the window and then construct it again
try:
self.right_scroll_area.deleteLater()
except Exception:
pass
self.right_scroll_area = QScrollArea()
self.right_scroll_widget = QWidget()
self.right_scroll_widget.setMinimumSize(800, 350 * len(self.game_report_content))
scroll_layout = QVBoxLayout()
scroll_layout.setAlignment(Qt.AlignHCenter)
self.right_scroll_widget.setLayout(scroll_layout)
self.right_scroll_area.setWidget(self.right_scroll_widget)
self.right_layout.addWidget(self.right_scroll_area)
# put items to the right side of the window
right_label = [QLabel() for i in range(len(self.game_report_content))]
for idx, item in enumerate(self.game_report_content):
if item is 'gif':
gif = QMovie("temp_gif/{}.gif".format(idx))
gif.setSpeed(125)
# the speed of gif needs some fine tuning, 125 means 1.25 times original speed
# the speed gets slower when using original speed
gif.setScaledSize(QSize(600, 357))
right_label[idx].setMovie(gif)
gif.start()
elif item is 0:
# this might happen when there's an advertisement image, see method GetNewsDetails
continue
else:
right_label[idx].setText(item)
right_label[idx].setFont(QFont("Microsoft YaHei", 12))
right_label[idx].setWordWrap(True)
right_label[idx].setAlignment(Qt.AlignCenter)
scroll_layout.addWidget(right_label[idx])
scroll_layout.addStretch(1)
class IconManagement(object):
def __init__(self, tray, interval = 100):
self.tray = tray
self.movie = QMovie(":/images/tray_animations/tray.gif")
self.movie.setSpeed(interval)
self.movie.frameChanged.connect(self.next_icon)
self.icons = Enum(
ok = QIcon(":/images/demerio.png"),
problem = QIcon(":/images/demerio-problem.png"),
conductor_problem = QIcon(":/images/demerio-conductor-problem.png")
)
self.icon = self.icons.ok
self.update_icon()
def internet_is_ok(self, internet_is_ok):
self.icon = self.icons.ok if internet_is_ok else self.icons.problem
self.update_icon()
@pyqtSlot(int)
def next_icon(self, i):
self.tray.setIcon(QIcon(self.movie.currentPixmap()))
def start(self):
self.movie.start()
def stop(self):
self.update_icon()
self.movie.stop()
def update_icon(self):
self.tray.setIcon(self.icon)
def conductor_problem(self):
if self.movie.state() == QMovie.Running:
self.movie.stop()
self.icon = self.icons.conductor_problem
self.update_icon()
class IconManagement(object):
def __init__(self, tray, interval=100):
self.tray = tray
self.movie = QMovie(":/images/tray_animations/tray.gif")
self.movie.setSpeed(interval)
self.movie.frameChanged.connect(self.next_icon)
self.icons = Enum(
ok=QIcon(":/images/demerio.png"),
problem=QIcon(":/images/demerio-problem.png"),
conductor_problem=QIcon(":/images/demerio-conductor-problem.png"))
self.icon = self.icons.ok
self.update_icon()
def internet_is_ok(self, internet_is_ok):
self.icon = self.icons.ok if internet_is_ok else self.icons.problem
self.update_icon()
@pyqtSlot(int)
def next_icon(self, i):
self.tray.setIcon(QIcon(self.movie.currentPixmap()))
def start(self):
self.movie.start()
def stop(self):
self.update_icon()
self.movie.stop()
def update_icon(self):
self.tray.setIcon(self.icon)
def conductor_problem(self):
if self.movie.state() == QMovie.Running:
self.movie.stop()
self.icon = self.icons.conductor_problem
self.update_icon()
class OCCMovie(dispocc):
def __init__(self, disp=True, touch=True):
super().__init__(disp=disp, touch=touch)
self.MovieMenu()
def MovieMenu(self):
self.add_menu("Movie")
self.add_function("Movie", self.export_cap)
self.add_function("Movie", self.movie_start)
self.add_function("Movie", self.movie_stop)
def movie_start(self):
"""sart animnation"""
# use an animated gif file you have in the working folder
# or give the full file path
self.movie = QMovie(self.tempname + ".gif", QByteArray(), self.wi)
self.movie.setCacheMode(QMovie.CacheAll)
self.movie.setSpeed(100)
# self.movie_screen.setMovie(self.movie)
self.movie.start()
def movie_stop(self):
"""stop the animation"""
self.movie.stop()
def frio(self):
if self.en_accion:
return
self.en_accion = True
# Mover jugador
paso = (self.enemigo.x() - self.jugador.x() - 165) / 10
for _ in range(10):
self.jugador.move(self.jugador.x() + paso, self.jugador.y())
self.sleep(0.03)
gif_frio = QMovie(self.rutas["frio"])
gif_frio.setSpeed(110)
self.jugador.setMovie(gif_frio)
gif_frio.start()
self.jugador.setFixedSize(207 * 1.3, 145 * 1.43)
self.sleep(1.18)
self.jugador.setFixedSize(91.75 * 1.1, 187.5 * 1.1)
self.jugador.setMovie(self.gif_jugador)
for _ in range(10):
self.jugador.move(self.jugador.x() - paso, self.jugador.y())
self.sleep(0.03)
# Fin Movida
self.en_accion = False
self.senal_envio_info_backend.emit("frio")
class ImageLabel(QMainWindow):
def __init__(self):
super().__init__()
self.label = QLabel()
self.label.setAlignment(Qt.AlignCenter)
self.label.setText('\n\n Drop Zip Files \n\n')
self.label.setStyleSheet('''
QLabel{
border: 4px dashed #aaa
}
''')
self.btn_icon = QPushButton('Save Location')
self.btn_icon.clicked.connect(self.json_change)
self.btn_icon.setIcon(QApplication.style().standardIcon(
QStyle.SP_DialogSaveButton))
self.movie = QMovie('photos/giphy.gif', QByteArray(), self)
layout = QVBoxLayout()
layout.addWidget(self.btn_icon)
layout.addWidget(self.label)
widget = QWidget()
widget.setLayout(layout)
self.setCentralWidget(widget)
def json_change(self):
with open('json/new.json', 'r') as json_file:
data = json.load(json_file)
files = QFileDialog.getExistingDirectory(self,
'Select extraction location')
print(files)
data['dir'] = files
# print(data)
with open('json/new.json', 'w') as json_file:
data = json.dump(data, json_file)
json_file.close()
def zipfile(self, path):
if path != '':
os.startfile(path)
# st= os.path.basename(path)
self.label.setText('FILES EXTRACTED : \n ' + path + '\n '
'\n'
'\nDRAG NEW FILES TO EXTRACT ')
self.movie.stop()
else:
self.label.setText('' '\nDRAG NEW FILES TO EXTRACT ')
self.label.setText('Extract destination not selected : '
' \n '
'\n '
'\n'
'\nDRAG NEW FILES TO EXTRACT ')
self.movie.stop()
def otherfile(self, path):
self.movie.stop()
st = os.path.basename(path)
self.label.setText('NOT A ZIP FILE: ' + st)
def loading(self):
# self.label.setText('Extracting Files...')
# self.movie.setCacheMode(QMovie.CacheAll)
self.movie.setSpeed(300)
QApplication.processEvents()
self.label.setMovie(self.movie)
self.movie.start()
class ImageViewer(QMainWindow):
def __init__(self):
super(ImageViewer, self).__init__()
self.printer = QPrinter()
self.scaleFactor = 0.0
self.imageLabel = QLabel()
self.imageLabel.setBackgroundRole(QPalette.Base)
self.imageLabel.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
self.imageLabel.setScaledContents(True)
self.imageLabel.setAlignment(Qt.AlignCenter)
self.scrollArea = QScrollArea()
self.scrollArea.setBackgroundRole(QPalette.Dark)
self.scrollArea.setWidget(self.imageLabel)
self.setCentralWidget(self.scrollArea)
self.scrollArea.setAlignment(Qt.AlignCenter)
self.createActions()
self.createMenus()
self.setWindowTitle("Image Viewer")
self.resize(500, 400)
self.setWindowIcon(QIcon('./res/Sketch-Icon.png'))
def open(self):
# 打开图片后根据weight重新调整大小
fileName, _ = QFileDialog.getOpenFileName(self, "Open File",
QDir.currentPath())
if fileName:
# 如果是webp格式用PIL
# 如果是psd用PSDtool
# gif格式？
fileType = fileName.split('.')[-1]
if fileType == 'gif':
#QMessageBox.information(self, "file type", "type:%s"%(fileType))
self.movie = QMovie(fileName)
self.movie.setCacheMode(QMovie.CacheAll)
self.movie.setSpeed(100)
self.imageLabel.setMovie(self.movie)
self.movie.start()
if not self.fitToWindowAct.isChecked():
self.imageLabel.adjustSize()
elif fileType == 'psd':
img = PSDImage.load(fileName)
img = img.as_PIL()
img.save('./res/temp.jpg')
image = QImage('./res/temp.jpg')
if image.isNull():
QMessageBox.information(self, "Image Viewer",
"Cannot load %s." % (fileName))
return
self.imageLabel.setPixmap(QPixmap.fromImage(image))
self.scaleFactor = 1.0
self.printAct.setEnabled(True)
self.fitToWindowAct.setEnabled(True)
self.updateActions()
if not self.fitToWindowAct.isChecked():
self.imageLabel.adjustSize()
elif fileType == 'svg':
svg = QtSvg.QSvgRenderer(fileName)
img = QImage(svg.defaultSize().width(), svg.defaultSize().height(), QImage.Format_ARGB32)
p = QPainter(img)
svg.render(p)
img.save('./res/temp.png')
p.end()
image = QImage('./res/temp.png')
if image.isNull():
QMessageBox.information(self, "Image Viewer",
"Cannot load %s." % (fileName))
return
self.imageLabel.setPixmap(QPixmap.fromImage(image))
self.scaleFactor = 1.0
self.printAct.setEnabled(True)
self.fitToWindowAct.setEnabled(True)
self.updateActions()
if not self.fitToWindowAct.isChecked():
self.imageLabel.adjustSize()
else:
image = QImage(fileName)
if image.isNull():
QMessageBox.information(self, "Image Viewer",
"Cannot load %s." % (fileName))
return
self.imageLabel.setPixmap(QPixmap.fromImage(image))
self.scaleFactor = 1.0
self.printAct.setEnabled(True)
self.fitToWindowAct.setEnabled(True)
self.updateActions()
if not self.fitToWindowAct.isChecked():
self.imageLabel.adjustSize()
def print_(self):
dialog = QPrintDialog(self.printer, self)
if dialog.exec_():
painter = QPainter(self.printer)
rect = painter.viewport()
size = self.imageLabel.pixmap().size()
size.scale(rect.size(), Qt.KeepAspectRatio)
painter.setViewport(rect.x(), rect.y(), size.width(), size.height())
painter.setWindow(self.imageLabel.pixmap().rect())
painter.drawPixmap(0, 0, self.imageLabel.pixmap())
def zoomIn(self):
self.scaleImage(1.25)
def zoomOut(self):
self.scaleImage(0.8)
def normalSize(self):
self.imageLabel.adjustSize()
self.scaleFactor = 1.0
def fitToWindow(self):
fitToWindow = self.fitToWindowAct.isChecked()
self.scrollArea.setWidgetResizable(fitToWindow)
if not fitToWindow:
self.normalSize()
self.updateActions()
def about(self):
QMessageBox.about(self, "About Image Viewer",
"<p>The <b>Image Viewer</b> example shows how to combine "
"QLabel and QScrollArea to display an image. QLabel is "
"typically used for displaying text, but it can also display "
"an image. QScrollArea provides a scrolling view around "
"another widget. If the child widget exceeds the size of the "
"frame, QScrollArea automatically provides scroll bars.</p>"
"<p>The example demonstrates how QLabel's ability to scale "
"its contents (QLabel.scaledContents), and QScrollArea's "
"ability to automatically resize its contents "
"(QScrollArea.widgetResizable), can be used to implement "
"zooming and scaling features.</p>"
"<p>In addition the example shows how to use QPainter to "
"print an image.</p>")
def rgbColor(self):
pass
def hexColor(self):
pass
def createActions(self):
self.openAct = QAction("&Open...", self, shortcut="Ctrl+O",
triggered=self.open)
self.printAct = QAction("&Print...", self, shortcut="Ctrl+P",
enabled=False, triggered=self.print_)
self.exitAct = QAction("E&xit", self, shortcut="Ctrl+Q",
triggered=self.close)
self.zoomInAct = QAction("Zoom &In (25%)", self, shortcut="Ctrl++",
enabled=False, triggered=self.zoomIn)
self.zoomOutAct = QAction("Zoom &Out (25%)", self, shortcut="Ctrl+-",
enabled=False, triggered=self.zoomOut)
self.normalSizeAct = QAction("&Normal Size", self, shortcut="Ctrl+S",
enabled=False, triggered=self.normalSize)
self.fitToWindowAct = QAction("&Fit to Window", self, enabled=False,
checkable=True, shortcut="Ctrl+F", triggered=self.fitToWindow)
self.rgbColor = QAction("&RGB Color", self, enabled=False,
checkable=True, triggered=self.rgbColor)
self.hexColor = QAction("&HEX Color", self, enabled=False,
checkable=True, triggered=self.hexColor)
self.aboutAct = QAction("&About", self, triggered=self.about)
self.aboutQtAct = QAction("About &Qt", self,
triggered=QApplication.instance().aboutQt)
def createMenus(self):
self.fileMenu = QMenu("&File", self)
self.fileMenu.addAction(self.openAct)
self.fileMenu.addAction(self.printAct)
self.fileMenu.addSeparator()
self.fileMenu.addAction(self.exitAct)
self.viewMenu = QMenu("&View", self)
self.viewMenu.addAction(self.zoomInAct)
self.viewMenu.addAction(self.zoomOutAct)
self.viewMenu.addAction(self.normalSizeAct)
self.viewMenu.addSeparator()
self.viewMenu.addAction(self.fitToWindowAct)
self.pickColor = QMenu("&PickColor", self)
self.pickColor.addAction(self.rgbColor)
self.pickColor.addAction(self.hexColor)
self.helpMenu = QMenu("&Help", self)
self.helpMenu.addAction(self.aboutAct)
self.helpMenu.addAction(self.aboutQtAct)
self.menuBar().addMenu(self.fileMenu)
self.menuBar().addMenu(self.viewMenu)
self.menuBar().addMenu(self.pickColor)
self.menuBar().addMenu(self.helpMenu)
def updateActions(self):
self.zoomInAct.setEnabled(not self.fitToWindowAct.isChecked())
self.zoomOutAct.setEnabled(not self.fitToWindowAct.isChecked())
self.normalSizeAct.setEnabled(not self.fitToWindowAct.isChecked())
def scaleImage(self, factor):
self.scaleFactor *= factor
self.imageLabel.resize(self.scaleFactor * self.imageLabel.pixmap().size())
self.adjustScrollBar(self.scrollArea.horizontalScrollBar(), factor)
self.adjustScrollBar(self.scrollArea.verticalScrollBar(), factor)
self.zoomInAct.setEnabled(self.scaleFactor < 3.0)
self.zoomOutAct.setEnabled(self.scaleFactor > 0.333)
def adjustScrollBar(self, scrollBar, factor):
scrollBar.setValue(int(factor * scrollBar.value()
+ ((factor - 1) * scrollBar.pageStep()/2)))
def __evt_loadstarted(self):
if not self.__loadlabel.movie():
movie = QMovie(getPath('iconDir','loading.gif'), QByteArray(), self.__loadlabel)
movie.setSpeed(50)
self.__loadlabel.setMovie(movie)
movie.start()
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 Parowka(Postac):
""" klasa rodzica dla wszystkich wrogów, w praktyce aby stworzyć nwego wroga wystarczy nowa klasa dziedzicząca,
dodanie jej jako cel do laseru gracza, oraz wywołanie odpowiedniego inita, ewentualnie nadpisaniu metod"""
def __init__(self, layout, ob_width=100, ob_height=100, speed=25, max_move=50, frequency_change_direction=50, shot_frequency=3500, *args):
super().__init__(layout, *args)
self.enemies.append(self)
self.make_random_pos(ob_width, ob_height)
self.setText("")
self.setPixmap(QtGui.QPixmap("images/parowa.png"))
self.setScaledContents(True)
self.speed = speed
self.max_move = max_move
self.frequency_change_direction = frequency_change_direction
self.shot_frequency = shot_frequency
self.start_enemy_action_clock()
self.start_enemy_shot_clock()
def make_random_pos(self, ob_width, ob_height): # ustawia parowke w losową pozycje
lb = int((self.okno.width() - self.okno.gWidth) / 2) # lewy bok
self.setGeometry(QtCore.QRect((lb + random.randint(10, (self.okno.gWidth - int(self.okno.gWidth/ob_width)))),
0, int(self.okno.gWidth/ob_width), int(self.okno.gHeight/ob_height)))
def start_enemy_action_clock(self):
""" tworzy zegar który odpowiada za ruch wrogów """
self.timer = QTimer()
self.timer.timeout.connect(self.move_enemy)
self.il_ruch_w_bok = random.randint(1, 26) # losuje ile ruchów odbyć w danym kierunku
self.enemy_move_licz = self.il_ruch_w_bok
self.enemy_move_direction = bool(random.getrandbits(1)) # losuje kierunek ruchu
self.timer.start(self.speed)
def move_enemy(self): # odpowiada za ruch wroga
if self.enemy_move_licz == 0: # jeśli licznik ruchu w jedną strone się skończył to go znów generuje
self.il_ruch_w_bok = random.randint(1, self.frequency_change_direction)
self.enemy_move_licz = self.il_ruch_w_bok
self.enemy_move_direction = bool(random.getrandbits(1)) # 1 - prawo, 0 - lewo
self.enemy_move_licz -= 1
e_x = self.x()
e_y = self.y()
if self.enemy_move_direction: # jeśli ruch jest true czyli 1 to dodaje x czyi przesuwa w prawo
e_x += self.max_move
else:
e_x -= self.max_move
if ((self.okno.gWidth + ((self.okno.width() - self.okno.gWidth) / 2)) - self.width()) >= e_x >= ((self.okno.width() - self.okno.gWidth) / 2): # odpowiada za odbijanie kierunku ruchu przy ścianie
self.setGeometry(e_x, e_y, self.width(), self.height())
else:
self.enemy_move_direction = not self.enemy_move_direction
def start_enemy_shot_clock(self):
self.stimer = QTimer()
self.stimer.timeout.connect(self.enemy_shot)
self.stimer.start(self.shot_frequency)
def enemy_shot(self):
x = SoundThread("shotLaserEnemy.wav")
x.start()
self.ui.centralwidget.close()
x = EnemyLaser(self.ui.centralwidget,
cause_geo=self.geometry()) # aby poprawnie dodać element do główneg widgetu należy go wyłączyć a następnie pokazać, czli zresetować
self.ui.centralwidget.show()
def explosion_animation(self):
self.disabled.append(self)
self.death_movie = QMovie("images/explosion.gif", QByteArray(), self)
self.death_movie.setCacheMode(QMovie.CacheAll)
self.death_movie.setSpeed(100) # ustala tak prędkość aby pokrywała się z szybkostrzelnością
self.setMovie(self.death_movie)
self.death_movie.start()
self.stimer.stop()
self.timer.stop()
self.death_timer = QTimer()
self.death_timer.timeout.connect(self.explosion_animation2)
self.death_timer.start(100)
def explosion_animation2(self):
self.disabled.remove(self)
self.kill()
if not self.enemies:
self.make_enemy_wave_early()
class Ui_Dialog(QtWidgets.QMainWindow):
sig = QtCore.pyqtSignal()
def add_item(self, widget, info):
form = AlertWidget(info)
a = QtWidgets.QListWidgetItem()
a.setSizeHint(form.sizeHint())
widget.insertItem(0, a)
widget.setItemWidget(a, form)
def __init__(self):
super().__init__()
uic.loadUi("UI/MainWindow.ui", self)
self.searchButton.clicked.connect(self.crawler_search)
self.movie = QMovie("loading.gif", QByteArray(), self.lblLogo)
self.movie.setCacheMode(QMovie.CacheAll)
self.movie.setSpeed(100)
self.lblLogo.setMovie(self.movie)
self.dw = None
alerts = open("alerts.txt", "r").readlines()
for line in alerts:
print(line[:-1])
self.add_item(self.newListWidget, line)
with open('history\history.txt', 'r') as fl:
dict = json.load(fl)
for key in dict.keys():
s = ""
for c in dict[key]:
s += c + "\n"
self.add_item(self.webListWidget, key)
self.show()
def resultScreen(self):
self.matchResult = crawlerResult.MatchGui((self.res[0], "alias"),
self.res[1])
self.matchResult.show()
self.movie.stop()
def setresult(self, res):
self.res = res
def crawler_search(self):
if self.dataButton.isChecked():
# data search = daniel hoch
print("Hello")
self.close()
import os
os.system('python main_ds.py %s' % str(self.searchEdit.text()))
elif self.webButton.isChecked():
# web search = dor salomon
# replace
self.movie.start()
print(self.movie.state())
self.sig.connect(self.resultScreen)
self.t = Thread(self)
self.t.start()
self.show()
'''if self.searchEdit.text() == "~test":
class ImagePlayer(QWidget):
"""Gif player"""
def __init__(self, parent=None):
"""Initialisation of GUI"""
QWidget.__init__(self, parent)
self.close_with_dialog = True
self.i_ip = 0
self.filename = QFileDialog.getOpenFileName(self, 'Open file', '.')[0]
if not self.filename:
sys.exit()
path = os.path.dirname(self.filename)
ldir = os.listdir(path=path)
os.chdir(path)
self.pall_widget = QWidget()
self.frames_widget = QWidget()
self.files = [
os.path.abspath(i) for i in ldir
if os.path.isfile(i) and GifInfo.try_parse(i)
]
if not self.files:
raise ValueError("There is no correct images")
if self.filename not in self.files:
descr = "Corrupt image"
inform = "Automatic select next image in directory..."
QMessageBox.about(self, descr, inform)
self.filename = self.files[0]
self.gifinfos = {self.filename: GifInfo(self.filename)}
self.gifinfo = self.gifinfos[self.filename]
self.f_ip = self.files.index(self.filename)
self.played = True
self.init_buttons()
self.init_qmovie()
self.init_main_layout()
self.setWindowTitle("Gif Parse")
self.tmp_widget = QWidget()
self.setLayout(self.main_layout)
def on_start(self):
"""Start playing"""
if self.played:
self.play_b.text = "Play"
self.movie.stop()
else:
self.play_b.text = "Stop"
self.movie.start()
self.played = not self.played
def init_qmovie(self):
"""QMovie Initialisation"""
self.movie = QMovie(self.filename, QByteArray(), self)
self.movie_screen = QLabel()
self.movie_screen.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.movie.setCacheMode(QMovie.CacheAll)
self.movie.setSpeed(100)
self.movie_screen.setMovie(self.movie)
self.movie.start()
def init_buttons(self):
"""Buttons Initialisation"""
self.play_b = QPushButton("&Play")
self.play_b.clicked.connect(self.on_start)
self.nxt_b = QPushButton(">")
self.nxt_b.clicked.connect(self.next_gif_b)
self.prv_b = QPushButton("<")
self.prv_b.clicked.connect(self.prev_gif_b)
self.info_b = QPushButton("&Info")
self.info_b.clicked.connect(self.on_info)
self.readme_b = QPushButton("&Readme")
self.readme_b.clicked.connect(self.on_readme)
def init_main_layout(self):
"""Initialization of main layout"""
self.main_layout = QGridLayout()
self.main_layout.setSpacing(2)
self.main_layout.addWidget(self.movie_screen, 0, 0, 1, 5)
self.main_layout.addWidget(self.play_b, 1, 1)
self.main_layout.addWidget(self.prv_b, 1, 0)
self.main_layout.addWidget(self.nxt_b, 1, 2)
self.main_layout.addWidget(self.info_b, 1, 3)
self.main_layout.addWidget(self.readme_b, 1, 4)
def on_info(self):
"""Show info"""
info = self.gifinfo
infos = []
infos.append(info.spec)
infos.append(str(info.size[0]) + "x" + str(info.size[1]))
infos.append(str(info.aratio))
infos.append(str(info.loops))
infos.append(str(len(info.frames)))
fields_name = [
"Type", "Size", "Ratio", "Count of loops", "Count of frames"
]
self.tmp_widget.setLayout(self.layout())
layout = QGridLayout(self)
layout.setSpacing(8)
back = QPushButton("Back")
back.clicked.connect(self.on_back)
full = QPushButton("Full info to txt")
full.clicked.connect(self.on_make_info)
for text, i in zip(infos, range(len(infos))):
widget = QLineEdit(text)
widget.setReadOnly(True)
layout.addWidget(QLabel(fields_name[i]), i, 0)
layout.addWidget(widget, i, 1, 1, 1)
if info.comments:
widget = QLineEdit(info.comments[0])
widget.setReadOnly(True)
layout.addWidget(QLabel("Comments:"), 6, 0)
layout.addWidget(widget, 6, 1)
pal_b = QPushButton("Pallete")
pal_b.clicked.connect(self.on_pallete_b)
fr_b = QPushButton("About frames")
fr_b.clicked.connect(self.on_frames_b)
layout.addWidget(pal_b, 7, 0)
layout.addWidget(fr_b, 7, 1)
layout.addWidget(full, 8, 0)
layout.addWidget(back, 8, 1)
self.setLayout(layout)
def on_readme(self):
"""Show readme"""
self.tmp_widget.setLayout(self.layout())
layout = QGridLayout(self)
layout.setSpacing(6)
back = QPushButton("Back")
back.clicked.connect(self.on_back)
with open(DIR + '/readme.txt', mode='r') as txt:
from_file = txt.read()
txt_widget = QTextEdit()
for line in from_file.split('\n'):
txt_widget.append(line)
txt_widget.setReadOnly(True)
layout.addWidget(txt_widget, 0, 0, 1, 5)
layout.addWidget(back, 5, 1)
self.setLayout(layout)
def on_back(self):
"""Back to main_layout"""
QWidget().setLayout(self.layout())
self.setLayout(self.tmp_widget.layout())
def on_back_pal(self):
"""Back to main_layout"""
QWidget().setLayout(self.layout())
self.setLayout(self.pall_widget.layout())
def on_back_frames(self):
"""Back to main_layout"""
QWidget().setLayout(self.layout())
self.setLayout(self.frames_widget.layout())
def on_make_info(self):
"""Make info file"""
name = str(os.path.basename(self.gifinfo.name)).split('.')[0]
if not os.path.exists(name + "info.txt"):
with open(name + "info.txt", mode='w') as file:
file.write(self.gifinfo.to_str())
QMessageBox.about(self, "Make txt", "Finished")
def closeEvent(self, event):
"""When window closed"""
quit_msg = "Are you sure you want to close this program?"
if self.close_with_dialog:
reply = QMessageBox.question(self, 'Message', quit_msg,
QMessageBox.Yes, QMessageBox.No)
else:
reply = QMessageBox.Yes
if reply == QMessageBox.Yes:
event.accept()
else:
event.ignore()
def contextMenuEvent(self, event):
"""Handling context Menu"""
menu = QMenu(self)
open_act = menu.addAction("Open new")
menu.addAction("Quit")
action = menu.exec_(self.mapToGlobal(event.pos()))
self.close_with_dialog = False
self.close()
if action == open_act:
main()
def next_gif(self, direction):
"""Choose next gif in directory"""
self.f_ip += direction
self.f_ip += len(self.files)
self.f_ip %= len(self.files)
self.i_ip = 0
self.filename = self.files[self.f_ip]
if self.filename not in self.gifinfos:
self.gifinfos[self.filename] = GifInfo(self.filename)
self.gifinfo = self.gifinfos[self.filename]
self.movie = QMovie(self.filename, QByteArray(), self)
self.movie_screen.setMovie(self.movie)
self.movie.start()
def next_gif_b(self):
"""nxt_b event"""
self.next_gif(1)
def prev_gif_b(self):
"""prv_b event"""
self.next_gif(-1)
def keyPressEvent(self, event):
"""Key pressed event"""
if event.key() == 44:
self.next_gif(-1)
elif event.key() == 46:
self.next_gif(1)
def on_pallete_b(self):
"""Make layout for pallete window"""
lay = QGridLayout()
wind = QWidget()
wind_lay = QGridLayout()
wind.setLayout(lay)
self.pall_widget.setLayout(self.layout())
for i, color in enumerate(self.gifinfo.colors):
lab = QLabel()
col = QColor(*color)
lab.setStyleSheet("QFrame { background-color: %s }" % col.name())
lay.addWidget(lab, i // 10, i % 10)
back = QPushButton("Back")
scroll = QScrollArea()
scroll.setWidget(wind)
scroll.setWidgetResizable(True)
scroll.setFixedHeight(200)
wind_lay.addWidget(scroll)
wind_lay.addWidget(back)
self.setLayout(wind_lay)
back.clicked.connect(self.on_back_pal)
@staticmethod
def make_frame_wid(frame):
"""Make specific widget for some gif's frame"""
lay = QGridLayout()
wid = QWidget()
colors = QWidget()
colors_lay = QGridLayout()
colors.setLayout(colors_lay)
data = []
data += (frame.x, frame.y)
data += (frame.width, frame.height)
data.append(frame.delay)
names = ["x", "y", "Width", "Heigth", "Delay"]
for i in range(len(data)):
lay.addWidget(QLabel(names[i]), i, 0)
widget = QLineEdit(str(data[i]))
widget.setReadOnly(True)
lay.addWidget(widget, i, 1)
for i, color in enumerate(frame.colors):
lab = QLabel()
col = QColor(*color)
lab.setStyleSheet("QFrame { background-color: %s }" % col.name())
colors_lay.addWidget(lab, 5 + i // 10, i % 10)
scroll = QScrollArea()
scroll.setWidget(colors)
scroll.setWidgetResizable(True)
scroll.setFixedHeight(200)
lay.addWidget(scroll, 4, 0, 2, 2)
wid.setLayout(lay)
return wid
def change_frame_lay(self, lay):
"""Select info about selected frame in ComboBox"""
self.lays[self.prev].setLayout(self.fr_wid.layout())
self.prev = lay
self.fr_wid.setLayout(self.lays[lay].layout())
def on_frames_b(self):
"""Frames info event"""
empty_lay = QGridLayout()
self.frames_widget.setLayout(self.layout())
self.lays = {}
self.prev = '0'
self.fr_wid = QWidget()
lay = QGridLayout()
for i, frame in enumerate(self.gifinfo.frames):
self.lays[str(i)] = ImagePlayer.make_frame_wid(frame)
combs = QComboBox()
combs.addItems([str(i) for i in range(len(self.gifinfo.frames))])
combs.activated[str].connect(self.change_frame_lay)
lay.addWidget(combs)
if self.lays:
self.fr_wid.setLayout(self.lays['0'].layout())
else:
self.fr_wid.setLayout(empty_lay)
lay.addWidget(self.fr_wid)
back = QPushButton("Back")
lay.addWidget(back)
back.clicked.connect(self.on_back_frames)
self.setLayout(lay)
class alarmChecker(QWidget):
def __init__(self, parent):
super(alarmChecker, self).__init__()
self.parent = parent
self.networkError = False
self.loadAlarm()
self.getAlarm()
self.getTimeout()
self.getTimer()
self.setLayout(self.alarm_layout)
def loadAlarm(self):
self.list_alarm = []
config = ConfigParser.ConfigParser()
config.readfp(open(self.parent.config_path + 'alarm.cfg'))
for a in config.sections():
dict = {"tableName": a}
for b in config.options(a):
dict[b] = config.get(a, b)
self.list_alarm.append(dict)
def getAlarm(self):
self.alarm_layout = QGridLayout()
self.movie = QMovie(self.parent.os_path + "/img/giphy2.gif", QByteArray(), self)
self.movie_screen = QLabel()
# Make label fit the gif
self.movie_screen.setFixedSize(80, 50)
# Add the QMovie object to the label
self.movie.setCacheMode(QMovie.CacheAll)
self.movie.setSpeed(100)
self.movie_screen.setMovie(self.movie)
self.movie.start()
self.timeout_ack = []
self.dialog = self.dialogTimeout()
self.dialog.hide()
self.label_acq = QPushButton("ACQUISITION")
self.label_acq.clicked.connect(self.dialog.show)
self.label_acq.setFixedHeight(50)
self.setColor("QPushButton", self.label_acq, "green")
self.alarm_layout.addWidget(self.movie_screen, 0, 0, 1, 1)
self.alarm_layout.addWidget(self.label_acq, 0, 1, 1, 2)
for i, device in enumerate(self.list_alarm):
name = device["tableName"] + device["key"]
button = QPushButton(device["label"].upper())
button.setFixedHeight(50)
self.setColor("QPushButton", button, "green")
button.clicked.connect(partial(self.showWarning, "msg_%s" % name))
self.alarm_layout.addWidget(button, 0, i + 3, 1, 1)
setattr(self, "alarm_%s" % name, button)
self.watcher_alarm = QTimer(self)
self.watcher_alarm.setInterval(5000)
self.watcher_alarm.timeout.connect(self.checkCriticalValue)
self.watcher_alarm.start()
def getTimeout(self):
self.device_dict = copy.deepcopy(self.parent.device_dict)
self.timeout_limit = 90
self.list_timeout = [key for key, value in self.parent.device_dict.iteritems()]
self.last_date = {}
self.last_time = {}
for key, value in self.device_dict.iteritems():
self.last_date[key] = 0
self.last_time[key] = datetime.datetime.now()
def getTimer(self):
watcher_timeout = QTimer(self)
watcher_timeout.singleShot(2000, partial(self.showTimeout, 0))
self.checker_timeout = QTimer(self)
self.checker_timeout.setInterval(15000)
self.checker_timeout.timeout.connect(self.checkTimeout)
self.checker_timeout.start()
def showTimeout(self, i):
for timeout in self.timeout_ack:
try:
self.list_timeout.remove(timeout)
except ValueError:
pass
if not self.networkError:
if self.list_timeout:
if i < len(self.list_timeout):
self.label_acq.setText("TIME OUT ON %s" % self.list_timeout[i])
self.setColor("QPushButton", self.label_acq, "red")
i += 1
else:
i = 0
else:
self.label_acq.setText("ACQUISITION")
self.setColor("QPushButton", self.label_acq, "green")
else:
self.label_acq.setText("SERVER LOST")
self.setColor("QPushButton", self.label_acq, "orange")
watcher_timeout = QTimer(self)
watcher_timeout.singleShot(2000, partial(self.showTimeout, i))
def checkTimeout(self):
for key, value in self.device_dict.iteritems():
return_values = self.parent.db.getLastData(key, "id")
if return_values == -5:
self.networkError = True
elif type(return_values) is int:
self.parent.showError(return_values)
else:
date, id = return_values
self.networkError = False
if date != self.last_date[key]:
if self.last_date[key] != 0:
if key in self.list_timeout:
self.list_timeout.remove(key)
self.last_time[key] = datetime.datetime.now()
self.last_date[key] = date
else:
if (datetime.datetime.now() - self.last_time[key]).total_seconds() > self.timeout_limit:
if key not in self.list_timeout:
self.list_timeout.append(key)
def checkCriticalValue(self):
for device in self.list_alarm:
name = device["tableName"] + device["key"]
return_values = self.parent.db.getLastData(device["tableName"], device["key"])
if type(return_values) is not int:
date, [val] = return_values
fmt = "{:.5e}" if len(str(val)) > 8 else "{:.2f}"
if float(device["lower_bound"]) <= val < float(device["higher_bound"]):
msg = "%s OK \r %s <= %s < %s" % (
device["label"], device["lower_bound"], fmt.format(val), device["higher_bound"])
self.setColor("QPushButton", getattr(self, "alarm_%s" % name), "green")
else:
msg = "WARNING ! %s OUT OF RANGE \r %s <= %s < %s" % (
device["label"], device["lower_bound"], fmt.format(val), device["higher_bound"])
self.setColor("QPushButton", getattr(self, "alarm_%s" % name), "red")
setattr(self, "msg_%s" % name, msg)
else:
print "code error : %i" % val
def setColor(self, type, widget, color):
if type == "QLabel":
widget.setStyleSheet(
"%s { background-color : %s; color : white; qproperty-alignment: AlignCenter; font: 15pt;}" % (
type, color))
else:
widget.setStyleSheet("%s { background-color : %s; color : white; font: 15pt;}" % (type, color))
def ackTimeout(self, checkbox):
if checkbox.isChecked():
if str(checkbox.text()) in self.timeout_ack:
self.timeout_ack.remove(str(checkbox.text()))
else:
self.timeout_ack.append(str(checkbox.text()))
def showWarning(self, attr):
reply = QMessageBox.warning(self, 'Message', str(getattr(self, attr)), QMessageBox.Ok)
def dialogTimeout(self):
d = QDialog(self)
d.setFixedWidth(450)
d.setWindowTitle("Setting Devices Timeout")
d.setVisible(True)
vbox = QVBoxLayout()
grid = QGridLayout()
grid.setSpacing(20)
for i, (key, value) in enumerate(self.parent.device_dict.iteritems()):
checkbox = QCheckBox(key)
checkbox.stateChanged.connect(partial(self.ackTimeout, checkbox))
checkbox.setCheckState(2)
grid.addWidget(checkbox, 1 + i, 0, 1, 3)
buttonBox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
buttonBox.button(QDialogButtonBox.Ok).clicked.connect(d.hide)
buttonBox.button(QDialogButtonBox.Cancel).clicked.connect(d.hide)
vbox.addLayout(grid)
vbox.addWidget(buttonBox)
d.setLayout(vbox)
return d
