花了两周读这个模块，终于把结构理清楚了，当然新功能也搞定了，搜索条件更宽松，可以找到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()
