def set_item(self, item_info, callback, errback, force_subtitles=False):
     threads.warn_if_not_on_main_thread('quicktime.Player.set_item')
     self.reset()
     qtmovie = self.get_movie_from_file(item_info.video_path)
     self.callback = callback
     self.errback = errback
     self.force_subtitles = force_subtitles
     if qtmovie is not None:
         self.item_info = item_info
         self.movie = qtmovie
         self.movie_notifications = NotificationForwarder.create(self.movie)
         self.movie_notifications.connect(self.handle_movie_notification,
             QTMovieDidEndNotification)
         load_state = qtmovie.attributeForKey_(
             QTMovieLoadStateAttribute).longValue()
         # Only setup a deferred notification if we are unsure of status
         # anything else in movie_load_state_changed().
         if load_state in (QTMovieLoadStateLoading,
                             QTMovieLoadStateLoaded):
             self.movie_notifications.connect(
                 self.handle_movie_notification,
                 QTMovieLoadStateDidChangeNotification)
         else:
             # Playable right away or error - just call and don't disconnect
             # notification because it wasn't connected in the first place.
             self.movie_load_state_changed(disconnect=False)
     else:
         threads.call_on_ui_thread(errback)

 def stop(self, will_play_another=False):
     threads.warn_if_not_on_main_thread('VideoPlayer.stop')
     self.prevent_system_sleep(True)
     self.video_view.pause_(nil)
     if self.video_window and not will_play_another:
         self.video_window.palette.remove()
     self.reset()

    def reveal(self, videoWindow):
        threads.warn_if_not_on_main_thread('OverlayPalette.reveal')
        self.resetAutoHiding()
        if (not self.window().isVisible() and not self.revealing) or (self.window().isVisible() and self.hiding):
            self.update_(nil)
            if self.renderer.movie is not None:
                self.set_volume(self.renderer.movie.volume())

            self.adjustPosition(videoWindow)
            self.adjustContent(videoWindow, False)

            if self.hiding and self.anim is not None:
                self.anim.stopAnimation()
                self.hiding = False
            else:
                self.window().setAlphaValue_(0.0)

            self.window().orderFront_(nil)
            videoWindow.parentWindow().addChildWindow_ordered_(self.window(), NSWindowAbove)

            self.revealing = True
            params = {NSViewAnimationTargetKey: self.window(), NSViewAnimationEffectKey: NSViewAnimationFadeInEffect}
            self.animate(params, 0.3)
        else:
            self.resumeAutoHiding()

 def reset(self):
     threads.warn_if_not_on_main_thread('quicktime.Player.reset')
     if self.movie_notifications is not None:
         self.movie_notifications.disconnect()
     self.movie_notifications = None
     self.movie = None
     self.item_info = None

 def reset(self):
     threads.warn_if_not_on_main_thread('quicktime.Player.reset')
     if self.movie_notifications is not None:
         self.movie_notifications.disconnect()
     self.movie_notifications = None
     self.movie = None
     self.callback = self.errback = None
     self.force_subtitles = False

 def remove(self):
     threads.warn_if_not_on_main_thread('OverlayPalette.remove')
     self.suspendAutoHiding()
     if self.updateTimer is not nil:
         self.updateTimer.invalidate()
         self.updateTimer = nil
     if self.window().parentWindow() is not nil:
         self.window().parentWindow().removeChildWindow_(self.window())
     self.window().orderOut_(nil)

 def set_item(self, item_info, callback, errback, force_subtitles=False):
     threads.warn_if_not_on_main_thread('quicktime.Player.set_item')
     qtmovie = self.get_movie_from_file(item_info.video_path)
     self.reset()
     if qtmovie is not None:
         self.movie = qtmovie
         self.item_info = item_info
         self.movie_notifications = NotificationForwarder.create(self.movie)
         self.movie_notifications.connect(self.handle_movie_notification, QTMovieDidEndNotification)
         self.setup_subtitles(force_subtitles)
         callback()
     else:
         errback()

    def hide(self):
        threads.warn_if_not_on_main_thread('OverlayPalette.hide')
        if not self.hiding:
            if self.autoHidingTimer is not nil:
                self.autoHidingTimer.invalidate()
                self.autoHidingTimer = nil

            if self.revealing and self.anim is not None:
                self.anim.stopAnimation()
                self.revealing = False

            self.hiding = True
            params = {NSViewAnimationTargetKey: self.window(), NSViewAnimationEffectKey: NSViewAnimationFadeOutEffect}
            self.animate(params, 0.5)

    def can_open_file(self, qtmovie):
        threads.warn_if_not_on_main_thread('quicktime.Player.can_open_file')
        can_open = False
        duration = utils.qttimevalue(qtmovie.duration())
        
        if qtmovie is not None and duration > 0:
            allTracks = qtmovie.tracks()
            if len(qtmovie.tracks()) > 0:
                # Make sure we have at least one track with a non zero length
                allMedia = [track.media() for track in allTracks]
                for media in allMedia:
                    mediaType = media.attributeForKey_(QTMediaTypeAttribute)
                    mediaDuration = utils.qttimevalue(media.attributeForKey_(QTMediaDurationAttribute).QTTimeValue())
                    if mediaType in self.supported_media_types and mediaDuration > 0:
                        can_open = True
                        break

        return can_open

 def setFloatValue_(self, value):
     threads.warn_if_not_on_main_thread('Slider.setFloatValue_')
     self.value = value
     self.setNeedsDisplay_(YES)

 def pause(self):
     threads.warn_if_not_on_main_thread('VideoPlayer.pause')
     self.video_view.pause_(nil)
     self.prevent_system_sleep(False)

 def play(self):
     threads.warn_if_not_on_main_thread('VideoPlayer.play')
     self.video_view.play_(nil)
     self.video_view.setNeedsDisplay_(YES)
     self.prevent_system_sleep(True)

 def pause(self):
     threads.warn_if_not_on_main_thread('AudioPlayer.pause')
     if self.movie is not None:
         self.movie.stop()

 def play(self):
     threads.warn_if_not_on_main_thread('AudioPlayer.play')
     if self.movie is not None:
         self.movie.play()