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 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()
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 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")
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()
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 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