Hiero中versionscanner模块结构图

花了两周读这个模块，终于把结构理清楚了，当然新功能也搞定了，搜索条件更宽松，可以找到binitem对象中更多的版本，截图如下：

当然功能也做出来啦：

代码如下：

##########################################################################################################################################

# ScanForVersions is the action responsible for scanning for versions.
# This action is added to the BinView context menu.
# The code responsible for the scanning is located in hiero.core.VersionScanner

import hiero.core
import hiero.core.log
import VersionScanner_vhq
import hiero.ui
import PySide.QtGui
import PySide.QtCore

import foundry.ui
import threading
import time

class VersionScannerThreaded (object):
  '''Class to run a threaded scan to discover additional versions for a set of versioned clips'''

  _scanner = VersionScanner_vhq.VersionScanner_vhq()

  def scanForVersions_vhq(self, versions, postScanFunc, shouldDisplayResults):
    '''Scan for versions starting from the specified version
       @param versions - set of versions to scan. Note that the versions listed belong to different bin items
       @param postScanFunc - optional post scan update function
       @param shouldDisplayResults - Whether we should display how many versions were discovered'''

    task = foundry.ui.ProgressTask("Finding Versions...")

    # Rescan clip file ranges for all existing versions
    for version in versions:
      hiero.core.executeInMainThreadWithResult(self.rescanClipRanges, version)

    # Find all the files to be added as versions
    numNewFiles = 0
    newVersionFiles = []
    numNewVersions = 0

    # For each version find the additional files
    for version in versions:
      newFiles = self._scanner.findVersionFiles_vhq(version)
      newVersionFiles.append ( [ version, newFiles ] )
      numNewFiles += len(newFiles)

    # Now create the clips for the additional files
    fileIndex = 0
    for versionFile in newVersionFiles:
      newClips = []

      version, newFiles = versionFile

      for newFile in newFiles:
        # If the user has hit cancel then drop out
        if task.isCancelled():
          return

        fileIndex += 1
        task.setProgress(int(100.0*(float(fileIndex)/float(numNewFiles))))
        newClip = hiero.core.executeInMainThreadWithResult(self._scanner.createClip, newFile)
        
        # Filter out any invalid clips
        if newClip is not None:
          newClips.append(newClip)

      versionFile.append ( newClips )

    # Now create the additional versions from the clips and add them to the version list
    for versionFile in newVersionFiles:
      version  = versionFile[0]
      newClips = versionFile[2]

      binitem = version.parent()

      # Now add the clips as new versions
      newVersions = hiero.core.executeInMainThreadWithResult(self._scanner.insertClips, binitem, newClips)

      hiero.core.log.info("InsertClips - Versions found for %s: %s", version, newVersions)

      numNewVersions += len(newVersions)

    # If we have a post scan function then run it (version up/down, min/max)
    if (postScanFunc is not None):
      oldClip = version.item()
      hiero.core.executeInMainThreadWithResult(postScanFunc)
      newClip = binitem.activeVersion().item()

      # Then update any viewers looking at the old clip to the new clip
      hiero.core.executeInMainThreadWithResult(hiero.ui.updateViewer, oldClip, newClip)

    # If we're supposed to display results then do so
    if (shouldDisplayResults):
      hiero.core.executeInMainThreadWithResult(self.displayResults, numNewVersions)

  # Display results
  def displayResults(self, numNewVersions):
    msgBox = PySide.QtGui.QMessageBox()
    msgBox.setText("Found " + str(numNewVersions) + " new versions")
    msgBox.setStandardButtons(PySide.QtGui.QMessageBox.Ok)
    msgBox.setDefaultButton(PySide.QtGui.QMessageBox.Ok)
    msgBox.exec_()

  # From an active version, iterates through all the siblings inside the BinItem
  def rescanClipRanges(self, activeVersion):
    binItem = activeVersion.parent()
    if binItem:
      for version in binItem.items():
        clip = version.item()
        if clip:
          clip.rescan()

# Helper class to call thread with a arbitrary number of arguments
class FuncThread(threading.Thread):
  def __init__(self, target, *args):
    self._target = target
    self._args = args
    threading.Thread.__init__(self)

  def run(self):
    self._target(*self._args)

def ScanAndNextVersion(version):
  '''Scan then move to next version'''
  binitem = version.parent()
  _DoScanForVersions([version], binitem.nextVersion, False)

def ScanAndPrevVersion(version):
  ''' Scan then move to prev version'''
  binitem = version.parent()
  _DoScanForVersions([version], binitem.prevVersion, False)

def ScanAndMinVersion(version):
  '''Scan then move to min version'''
  binitem = version.parent()
  _DoScanForVersions([version], binitem.minVersion, False)

def ScanAndMaxVersion(version):
  '''Scan then move to max version'''
  binitem = version.parent()
  _DoScanForVersions([version], binitem.maxVersion, False)

def ScanAndNextVersionTrackItem(version, trackItem):
  '''Scan then move to next version on the track item'''
  _DoScanForVersions([version], trackItem.nextVersion, False)

def ScanAndPrevVersionTrackItem(version, trackItem):
  '''Scan then move to prev version on the track item'''
  _DoScanForVersions([version], trackItem.prevVersion, False)

def ScanAndMinVersionTrackItem(version, trackItem):
  '''Scan then move to min version on the track item'''
  _DoScanForVersions([version], trackItem.minVersion, False)

def ScanAndMaxVersionTrackItem(version, trackItem):
  '''Scan then move to max version on the track item'''
  _DoScanForVersions([version], trackItem.maxVersion, False)

# Create threaded scan using VersionScannerThreaded
def _DoScanForVersions(versions, postUpdateFunc, shouldDisplayResults):

  scanner = VersionScannerThreaded()

  thread = FuncThread(scanner.scanForVersions_vhq, versions, postUpdateFunc, shouldDisplayResults)
  thread.start()

# Action to scan for new versions
class ScanForVersionsAction(PySide.QtGui.QAction):

  _scanner = hiero.core.VersionScanner.VersionScanner()

  def __init__(self):
      PySide.QtGui.QAction.__init__(self, "Scan For More Versions (VHQ)", None)
      self.triggered.connect(self.doit)
      hiero.core.events.registerInterest((hiero.core.events.EventType.kShowContextMenu, hiero.core.events.EventType.kBin), self.eventHandler)
      hiero.core.events.registerInterest((hiero.core.events.EventType.kShowContextMenu, hiero.core.events.EventType.kTimeline), self.eventHandler)


  def doit(self):
    # get the currently selected versions from UI
    versions = self.selectedVersions()

    if len(versions) == 0:
      hiero.core.log.info( "No valid versions found in selection" )
      return

    # For each version, do:
    # - rescan any versions already loaded to find the maximum available range
    # - run _scanner.doScan which returns added versions
    # - compute the total count of new versions.
    _DoScanForVersions(versions, None, True)

  def eventHandler(self, event):

    enabled = False
    if hasattr(event.sender, 'selection'):
      s = event.sender.selection()
      if len(s)>=1:
        enabled = True

      # enable/disable the action each time
      if enabled:
        hiero.ui.insertMenuAction( self, event.menu, after="foundry.project.rescanClips" ) # Insert after 'Version' sub-menu

  # Get all selected active versions
  def selectedVersions(self):
    selection = hiero.ui.currentContextMenuView().selection()
    versions = []
    self.findActiveVersions(selection, versions)
    return (versions)

  #
  def alreadyHaveVersion(self, findversion, versions):
    newFilename = findversion.item().mediaSource().fileinfos()[0].filename()
    for version in versions:
      thisFilename = version.item().mediaSource().fileinfos()[0].filename()
      if (newFilename == thisFilename):
        return True

    return False

  # Find all active versions in container and append to versions
  def findActiveVersions(self, container, versions):
    # Iterate through selection
    if isinstance(container, (list,tuple)):
      for i in container:
        self.findActiveVersions(i, versions)
    # Dive into Projects to find clipsBin (NB: not strictly needed at the moment, we get RootBins from BinView)
    elif isinstance(container, hiero.core.Project):
      self.findActiveVersions(container.clipsBin(), versions)
    # Dive into Bins to find BinItems
    elif isinstance(container, hiero.core.Bin):
      for i in container.items():
        self.findActiveVersions(i, versions)
    elif isinstance(container, hiero.core.TrackItem) and isinstance(container.source(), hiero.core.Clip):
      activeVersion = container.currentVersion()
      if activeVersion and not activeVersion.isNull():
        if not self.alreadyHaveVersion(activeVersion, versions):
        #if activeVersion not in versions:
          versions.append(activeVersion)
    # Dive into BinItem to retrieve active Version
    elif isinstance(container, hiero.core.BinItem) and isinstance(container.activeItem(), hiero.core.Clip):
      activeVersion = container.activeVersion()
      if activeVersion:
        if not self.alreadyHaveVersion(activeVersion, versions):
        #if activeVersion not in versions:
          versions.append(activeVersion)

# Instantiate the action to get it to register itself.
action = ScanForVersionsAction()