Python QtGui.QMovie类代码示例

class SystemTrayIcon(QSystemTrayIcon):
    def __init__(self, parent):
        super(SystemTrayIcon, self).__init__()
        self.parent = parent

        self.new_folder_window = NewFolderWindow(parent)
        self.preferences_window = PreferencesWindow()
        
        self.setIcon(QIcon(":gridsync.png"))

        self.right_menu = RightClickMenu(self)
        self.setContextMenu(self.right_menu)
        self.activated.connect(self.on_click)

        self.animation = QMovie()
        self.animation.setFileName(":sync.gif")
        self.animation.updated.connect(self.update_animation_frame)
        self.animation.setCacheMode(True)

    def update_animation_frame(self):
        self.setIcon(QIcon(self.animation.currentPixmap()))

    def set_icon(self, resource):
        self.setIcon(QIcon(resource))

    def on_click(self, value):
        #self.right_menu.populate()
        if value == QSystemTrayIcon.Trigger:
            open_gridsync_folder()

    def on_quit(self):
        reactor.stop()

 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 MoviePlayer(QWidget):
    def __init__(self):
        super(MoviePlayer, self).__init__()

        self.setAttribute(Qt.WA_TranslucentBackground)        
        self.setWindowFlags(Qt.FramelessWindowHint)

        self.movie = QMovie(self)

        self.movieLabel = QLabel("No movie loaded")
        self.movieLabel.setAlignment(Qt.AlignAbsolute)
        self.movieLabel.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)


        self.mainLayout = QVBoxLayout()
        self.mainLayout.addWidget(self.movieLabel)
        self.setLayout(self.mainLayout)
        
        #self.resize(400, 500)

        self.movieLabel.setMovie(self.movie)
        self.movie.setFileName('icon/gears.gif')

        pos = kp.pos()

        x = pos.x() - ((self.width()/2) - (kp.width()/2)) +220
        y = pos.y() - ((self.height()/2) - (kp.height()/2)) +160
        
        self.setGeometry(x,y, 400, 500)

        self.movie.start()   

class StatusBarView(QStatusBar):
    """
    The model of Navigation component
    """

    def __init__(self, parent):
        super().__init__(parent)

        self.status_label = QLabel("", parent)
        self.status_label.setTextFormat(Qt.RichText)

        self.label_time = QLabel("", parent)

        self.combo_referential = QComboBox(parent)
        self.movie_loader = QMovie(":/icons/loader")
        self.label_loading = QLabel(parent)
        self.label_loading.setMovie(self.movie_loader)
        self.label_loading.setMaximumHeight(self.height())
        self.movie_loader.setScaledSize(QSize(16, 16))
        self.movie_loader.start()
        self.movie_loader.setPaused(True)
        self.addPermanentWidget(self.label_loading)
        self.addPermanentWidget(self.status_label, 2)
        self.addPermanentWidget(self.label_time)
        self.addPermanentWidget(self.combo_referential)

    def start_loading(self):
        self.movie_loader.setPaused(False)

    def stop_loading(self):
        self.movie_loader.setPaused(True)

    def initoptionspanel(self):
        label = QLabel('Filter')

        filtertype = QComboBox()
        filtertype.addItem('None')
        filtertype.addItem('Lowpass')
        filtertype.addItem('Highpass')
        filtertype.addItem('Bandreject')
        filtertype.addItem('Bandpass')
        filtertype.currentIndexChanged.connect(self.filtertypelistener)

        self.filterfunction = QComboBox()
        self.filterfunction.addItem('Ideal')
        self.filterfunction.addItem('Butterworth')
        self.filterfunction.addItem('Gaussian')
        self.filterfunction.currentIndexChanged.connect(self.filterfunctionlistener)
        self.filterfunction.setEnabled(False)

        self.filtercutoff = QDoubleSpinBox()
        self.filtercutoff.setValue(0.0)
        self.filtercutoff.setRange(0.0, 10000.0)
        self.filtercutoff.valueChanged.connect(self.filtercutofflistener)
        self.filtercutoff.setEnabled(False)

        self.filterbandwidth = QDoubleSpinBox()
        self.filterbandwidth.setValue(1.0)
        self.filterbandwidth.setRange(0.0, 10000.0)
        self.filterbandwidth.valueChanged.connect(self.filterbandwidthlistener)
        self.filterbandwidth.setEnabled(False)

        self.filterorder = QDoubleSpinBox()
        self.filterorder.setValue(1.0)
        self.filterorder.setRange(0.0, 10000.0)
        self.filterorder.valueChanged.connect(self.filterorderlistener)
        self.filterorder.setEnabled(False)

        loader = QMovie('loader.gif')
        loader.start()
        self.loadercontainer = QLabel()
        self.loadercontainer.setMovie(loader)
        self.loadercontainer.setVisible(False)

        formlayout = QFormLayout()
        formlayout.addRow('Type', filtertype)
        formlayout.addRow('Function', self.filterfunction)
        formlayout.addRow('Cut off', self.filtercutoff)
        formlayout.addRow('Bandwidth', self.filterbandwidth)
        formlayout.addRow('Order', self.filterorder)
        formlayout.addRow('', self.loadercontainer)

        filterbox = QGroupBox('Filter')
        filterbox.setLayout(formlayout)

        options = QDockWidget('Options')
        options.setFeatures(QDockWidget.DockWidgetFloatable)
        options.setFeatures(QDockWidget.DockWidgetMovable)
        options.setWidget(filterbox)
        self.addDockWidget(Qt.RightDockWidgetArea, options)

class LoadingGifWin( QWidget):
    def __init__(self,parent=None):
        super(LoadingGifWin, self).__init__(parent)
        self.label =  QLabel('', self)
        self.setFixedSize(128,128)
        self.setWindowFlags( Qt.Dialog| Qt.CustomizeWindowHint)
        self.movie =  QMovie("./images/loading.gif")
        self.label.setMovie(self.movie)
        self.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()

class WaitDialog(QWidget):
    def __init__(self, parent=None, *args, **kwargs):
        super(WaitDialog, self).__init__(parent)
        self.label = QLabel(self)
        self.label.setAlignment(Qt.AlignCenter)
        self.setFixedSize(551, 401)
        self.setWindowOpacity(0.5)  # set transparent
        self.setWindowFlags(Qt.Dialog | Qt.CustomizeWindowHint | Qt.FramelessWindowHint)
        self.setAttribute(Qt.WA_TranslucentBackground)  # background transparent
        self.setContentsMargins(0, 0, 0, 0)
        config = Config()
        self.movie = QMovie(os.path.join(config.images, 'wait.gif'))
        self.label.setMovie(self.movie)
        self.movie.start()

 def __init__(self):
     super(MainWindow, self).__init__()
     self.ui = Ui_MainWindow()
     self.ui.setupUi(self)
     self.ui.searchEdit.textChanged.connect(self.search_text_changed)
     self.ui.show_button.clicked.connect(self.show_episodes)
     self.ui.searchEdit.returnPressed.connect(self.show_episodes)
     self.episodes = None
     self.episode_list = None
     self.number = 0
     self.anime_list = None
     self.ui.download_button.clicked.connect(self.download)
     self.ui.res_list_widget.currentItemChanged.connect(self.episode_change)
     self.com = Comunicate()
     self.com.sig.connect(self.message)
     self.com.img.connect(self.set_image)
     self.ui.anime_list_widget.itemDoubleClicked.connect(self.show_episodes)
     self.setWindowIcon(QIcon(get_file('animes.png')))
     self.ui.anime_list_widget.itemPressed.connect(self.anime_entered)
     Thread(target=self.load_url_items).start()
     #self.load_url_items()
     self.movie = QMovie(get_file('ajax-loader.gif'))
     self.ui.loading_label.setMovie(self.movie)
     self.link = None
     self.main_download_page = None
     self.tray = SystemTrayIcon(
         QIcon(get_file('animes.png')), self.com, self)
     self.com.op.connect(self.show_semard)
     self.ui.action_About_Semard.triggered.connect(self.about_semard)
     self.ui.action_Contato.triggered.connect(self.show_feedback)
     self.setWindowTitle('Semard - Animes')
     self.browser = None
     self.player = None

 def __init__(self, parent=None):
     super(XNCStatusBar, self).__init__(parent)
     # state vars
     self.world = XNovaWorld_instance()
     # initialization
     self.setSizeGripEnabled(True)
     # sub-widgets
     # progressbar
     self._progressbar = QProgressBar(self)
     self._progressbar.hide()
     self._progressbar.setValue(0)
     self._progressbar.setRange(0, 99)
     # online players counter
     self._lbl_online = QLabel(self.tr('Online') + ': 0', self)
     # label with loading.gif
     self._loading_gif = QMovie(':/i/loading.gif')
     self._lbl_loading = QLabel(self)
     self._lbl_loading.setMovie(self._loading_gif)
     self._lbl_loading.hide()
     # testing only
     self._btn_runscript = QPushButton('Run script', self)
     self._btn_runscript.clicked.connect(self.on_run_script)
     self.addPermanentWidget(self._btn_runscript)
     #
     self.addPermanentWidget(self._lbl_loading)
     self.addPermanentWidget(self._lbl_online)  # should be las right widget
     self.show()

    def __init__(self, parent=None):
        super(MoviePlayer, self).__init__(parent)

        self.movie = QMovie(self)
        self.movie.setCacheMode(QMovie.CacheAll)

        self.movieLabel = QLabel("No movie loaded")
        self.movieLabel.setAlignment(Qt.AlignCenter)
        self.movieLabel.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
        self.movieLabel.setBackgroundRole(QPalette.Dark)
        self.movieLabel.setAutoFillBackground(True)

        self.currentMovieDirectory = ''

        self.createControls()
        self.createButtons()

        self.movie.frameChanged.connect(self.updateFrameSlider)
        self.movie.stateChanged.connect(self.updateButtons)
        self.fitCheckBox.clicked.connect(self.fitToWindow)
        self.frameSlider.valueChanged.connect(self.goToFrame)
        self.speedSpinBox.valueChanged.connect(self.movie.setSpeed)

        mainLayout = QVBoxLayout()
        mainLayout.addWidget(self.movieLabel)
        mainLayout.addLayout(self.controlsLayout)
        mainLayout.addLayout(self.buttonsLayout)
        self.setLayout(mainLayout)

        self.updateFrameSlider()
        self.updateButtons()

        self.setWindowTitle("Movie Player")
        self.resize(400, 400)

 def setPath(self, path):
     if hasattr(self, "_movie"):
         self._movie.stop()
         del self._movie
     if not path:
         return
     self._movie = QMovie(path)
     self.setMovie(self._movie)
     self._movie.start()

    def __init__(self, parent=None):
        super(MainWindow, self).__init__(parent)
        self.setGeometry(50, 50, 600, 750)
        self.setFixedSize(500, 500)
        self.startUIWindow()

        self.movie = QMovie("mail.gif")
        self.movie.frameChanged.connect(self.repaint)
        self.movie.start()

class LoadingItem(QLabel):

    def __init__(self):
        super(LoadingItem, self).__init__()
        self.movie = QMovie(resources.IMAGES['loading'])
        self.setMovie(self.movie)
        self.movie.setScaledSize(QSize(16, 16))
        self.movie.start()

    def add_item_to_tree(self, folder, tree, item_type=None, parent=None):
        if item_type is None:
            item = QTreeWidgetItem()
            item.setText(0, (_translate("LoadingItem", "       LOADING: '%s'") % folder))
        else:
            item = item_type(parent, (
                _translate("LoadingItem", "       LOADING: '%s'") % folder), folder)
        tree.addTopLevelItem(item)
        tree.setItemWidget(item, 0, self)
        return item

    def __init__(self, parent, text=""):
        QDialog.__init__(self, parent)

        # Create waiting image
        waitingImage = QMovie(qtUtils.getAbsoluteImagePath('waiting.gif'))
        waitingImage.start()
        waitingImageLabel = QLabel(self)
        waitingImageLabel.setMovie(waitingImage)

        waitingLabel = QLabel(text, self)

        hbox = QHBoxLayout()
        hbox.addStretch(1)
        hbox.addWidget(waitingImageLabel)
        hbox.addSpacing(10)
        hbox.addWidget(waitingLabel)
        hbox.addStretch(1)

        self.setLayout(hbox)