def __init__(self, environment=None, parent=None, reference_resolution=None): super(MainDialog, self).__init__(parent) self.setupUi(self) # change the window title self.setWindowTitle(self.windowTitle()) # center to the window self.center_window() self.new_versions = [] # setup the environment self.environment = self._validate_environment(environment) if reference_resolution is None: # generate from environment if self.environment: reference_resolution = \ self.environment.check_referenced_versions() else: # create an empty one reference_resolution = empty_reference_resolution() self.reference_resolution = reference_resolution self.setup_signals() self._fill_UI()
def open(self, version, force=False, representation=None, reference_depth=0, skip_update_check=False): """Opens the given version file :param version: The Stalker version instance :param force: force open, so don't care if there are any unsaved changes in the current scene. :param representation: The desired representation for the XRef files (Not Implemented) :param reference_depth: (Not Implemented) :param skip_update_check: (Not Implemented) :return: Returns a reference resolution that shows what to update. """ # before open: set the system units and gamma settings to their # defaults self.set_system_units() self.set_gamma_settings() # set the project dir self.set_project(version) # then open the file MaxPlus.FileManager.Open(version.absolute_full_path, True) if not skip_update_check: # check the referenced versions for any possible updates return self.check_referenced_versions() else: from anima.env import empty_reference_resolution return empty_reference_resolution()
def open(self, version, force=False, representation=None, reference_depth=0, skip_update_check=False): """the open action for nuke environment """ version_full_path = os.path.normpath(version.absolute_full_path) # delete all the comps and open new one #comps = self.fusion.GetCompList().values() #for comp_ in comps: # comp_.Close() self.fusion.LoadComp(version_full_path.encode()) rfm = RecentFileManager() rfm.add(self.name, version.absolute_full_path) # set the project_directory #self.project_directory = os.path.dirname(version.absolute_path) # TODO: file paths in different OS'es should be replaced with the current one # Check if the file paths are starting with a string matching one of # the OS'es project_directory path and replace them with a relative one # matching the current OS # replace paths #self.replace_external_paths() # return True to specify everything was ok and an empty list # for the versions those needs to be updated return empty_reference_resolution()
def open(self, version, force=False, representation=None, reference_depth=0, skip_update_check=False): """the open action for nuke environment """ nuke.scriptOpen(version.absolute_full_path) # set the project_directory self.project_directory = os.path.dirname(version.absolute_path) # TODO: file paths in different OS's should be replaced with the current one # Check if the file paths are starting with a string matching one of the # OS's project_directory path and replace them with a relative one # matching the current OS # replace paths self.replace_external_paths() # return True to specify everything was ok and an empty list # for the versions those needs to be updated from anima.env import empty_reference_resolution return empty_reference_resolution()
def open(self, version, force=False, representation=None, reference_depth=0, skip_update_check=False): """the open action for houdini environment """ if not version: return if hou.hipFile.hasUnsavedChanges() and not force: raise RuntimeError hou.hipFile.load(file_name=str(version.absolute_full_path), suppress_save_prompt=True) # set the environment variables self.set_environment_variables(version) # append it to the recent file list self.append_to_recent_files(version.absolute_full_path) from anima.env import empty_reference_resolution return empty_reference_resolution()
def open(self, version, force=False, representation=None, reference_depth=0, skip_update_check=False): """open action for photoshop environment :param version: stalker.models.version.Version instance :param force: force open file :return: """ version_full_path = version.absolute_full_path version_full_path = version_full_path.replace('/', '\\') self.photoshop.Load(version_full_path) rfm = RecentFileManager() rfm.add(self.name, version.absolute_full_path) return empty_reference_resolution()
def open(self, version, force=False, representation=None, reference_depth=0, skip_update_check=False): """The overridden open method :param version: :param force: :param representation: :param reference_depth: :param skip_update_check: :return: """ self.app.FileOpen( str(version.absolute_full_path) ) from anima.env import empty_reference_resolution return empty_reference_resolution()
def generate_reference_resolution(self): """Generates a new reference_resolution dictionary from the UI :return: dictionary """ generated_reference_resolution = empty_reference_resolution() # append anything that is checked version_tree_model = self.versions_treeView.model() for i in range(version_tree_model.rowCount()): index = version_tree_model.index(i, 0) version_item = version_tree_model.itemFromIndex(index) if version_item.checkState() == QtCore.Qt.Checked: version = version_item.version generated_reference_resolution['update'].append(version) return generated_reference_resolution
def open(self, version, force=False, representation=None, reference_depth=0, skip_update_check=False): """the open action for nuke environment """ nuke.scriptOpen(version.absolute_full_path) # set the project_directory # self.project_directory = os.path.dirname(version.absolute_path) # TODO: file paths in different OS'es should be replaced with the current one # Check if the file paths are starting with a string matching one of the # OS'es project_directory path and replace them with a relative one # matching the current OS # replace paths # self.replace_external_paths() # return True to specify everything was ok and an empty list # for the versions those needs to be updated return empty_reference_resolution()
def open(self, version, force=False, representation=None, reference_depth=0, skip_update_check=False): """the open action for nuke environment """ version_full_path = os.path.normpath(version.absolute_full_path) # # delete all the comps and open new one # comps = self.fusion.GetCompList().values() # for comp_ in comps: # comp_.Close() self.fusion.LoadComp(version_full_path if sys.version_info[0] >= 3 else version_full_path.encode()) self.comp.Lock() # set the project_directory # get the current comp fist self.comp = self.fusion.GetCurrentComp() self.project_directory = os.path.dirname(version.absolute_path) # update the savers self.create_main_saver_node(version) # file paths in different OS'es should be replaced with a path that is suitable for the current one # update loaders self.fix_loader_paths() self.comp.Unlock() rfm = RecentFileManager() rfm.add(self.name, version.absolute_full_path) # return True to specify everything was ok and an empty list # for the versions those needs to be updated return empty_reference_resolution()
def open(self, version, force=False, representation=None, reference_depth=0, skip_update_check=False): """the open action for houdini environment """ if not version: return if hou.hipFile.hasUnsavedChanges() and not force: raise RuntimeError hou.hipFile.load( file_name=str(version.absolute_full_path), suppress_save_prompt=True ) # set the environment variables self.set_environment_variables(version) # append it to the recent file list self.append_to_recent_files( version.absolute_full_path ) return empty_reference_resolution()
def check_referenced_versions(self): """Deeply checks all the references in the scene and returns a dictionary which uses the ids of the Versions as key and the action as value. Uses the top level references to get a Stalker Version instance and then tracks all the changes from these Version instances. :return: list """ # reverse walk in DFS dfs_version_references = [] version = self.get_current_version() resolution_dictionary = empty_reference_resolution( root=self.get_referenced_versions() ) # TODO: with Stalker v0.2.5 replace this with Version.walk_inputs() for v in version.walk_hierarchy(): dfs_version_references.append(v) # pop the first element which is the current scene dfs_version_references.pop(0) # iterate back in the list for v in reversed(dfs_version_references): # check inputs first to_be_updated_list = [] for ref_v in v.inputs: if not ref_v.is_latest_published_version(): to_be_updated_list.append(ref_v) if to_be_updated_list: action = 'create' # check if there is a new published version of this version # that is using all the updated versions of the references latest_published_version = v.latest_published_version if latest_published_version and \ not v.is_latest_published_version(): # so there is a new published version # check if its children needs any update # and the updated child versions are already # referenced to the this published version if all([ref_v.latest_published_version in latest_published_version.inputs for ref_v in to_be_updated_list]): # so all new versions are referenced to this published # version, just update to this latest published version action = 'update' else: # not all references are in the inputs # so we need to create a new version as usual # and update the references to the latest versions action = 'create' else: # nothing needs to be updated, # so check if this version has a new version, # also there could be no reference under this referenced # version if v.is_latest_published_version(): # do nothing action = 'leave' else: # update to latest published version action = 'update' # before setting the action check all the inputs in # resolution_dictionary, if any of them are update, or create # then set this one to 'create' if any(rev_v in resolution_dictionary['update'] or rev_v in resolution_dictionary['create'] for rev_v in v.inputs): action = 'create' # so append this v to the related action list resolution_dictionary[action].append(v) return resolution_dictionary
def check_referenced_versions(self): """Deeply checks all the references in the scene and returns a dictionary which uses the ids of the Versions as key and the action as value. Uses the top level references to get a Stalker Version instance and then tracks all the changes from these Version instances. :return: list """ # reverse walk in DFS dfs_version_references = [] version = self.get_current_version() resolution_dictionary = empty_reference_resolution( root=self.get_referenced_versions()) # TODO: with Stalker v0.2.5 replace this with Version.walk_inputs() for v in version.walk_hierarchy(): dfs_version_references.append(v) # pop the first element which is the current scene dfs_version_references.pop(0) # iterate back in the list for v in reversed(dfs_version_references): # check inputs first to_be_updated_list = [] for ref_v in v.inputs: if not ref_v.is_latest_published_version(): to_be_updated_list.append(ref_v) if to_be_updated_list: action = 'create' # check if there is a new published version of this version # that is using all the updated versions of the references latest_published_version = v.latest_published_version if latest_published_version and \ not v.is_latest_published_version(): # so there is a new published version # check if its children needs any update # and the updated child versions are already # referenced to the this published version if all([ ref_v.latest_published_version in latest_published_version.inputs for ref_v in to_be_updated_list ]): # so all new versions are referenced to this published # version, just update to this latest published version action = 'update' else: # not all references are in the inputs # so we need to create a new version as usual # and update the references to the latest versions action = 'create' else: # nothing needs to be updated, # so check if this version has a new version, # also there could be no reference under this referenced # version if v.is_latest_published_version(): # do nothing action = 'leave' else: # update to latest published version action = 'update' # before setting the action check all the inputs in # resolution_dictionary, if any of them are update, or create # then set this one to 'create' if any(rev_v in resolution_dictionary['update'] or rev_v in resolution_dictionary['create'] for rev_v in v.inputs): action = 'create' # so append this v to the related action list resolution_dictionary[action].append(v) return resolution_dictionary
def check_referenced_versions(self, pdm=None): """Deeply checks all the references in the scene and returns a dictionary which has three keys called 'leave', 'update' and 'create'. Each of these keys correspond to a value of a list of :class:`~stalker.model.version.Version`\ s. Where the list in 'leave' key shows the Versions referenced (or deeply referenced) to the current scene which doesn't need to be changed. The list in 'update' key holds Versions those need to be updated to a newer version which are already exist. The list in 'create' key holds Version instance which needs to have its references to be updated to the never versions thus need a new version for them self. All the Versions in the list are sorted from the deepest to shallowest reference, so processing the list from 0th element to nth will always guarantee up to date info for the currently processed Version instance. Uses the top level references to get a Stalker Version instance and then tracks all the changes from these Version instances. :return: dictionary """ if not pdm: from anima.ui.progress_dialog import ProgressDialogManager pdm = ProgressDialogManager() caller = \ pdm.register( 3, '%s.check_referenced_versions() prepare data' % self.__class__.__name__ ) # deeply get which file is referencing which other files self.deep_version_inputs_update() if caller: caller.step() from anima.env import empty_reference_resolution reference_resolution = \ empty_reference_resolution(root=self.get_referenced_versions()) if caller: caller.step() # reverse walk in DFS dfs_version_references = [] version = self.get_current_version() if not version: return reference_resolution for v in version.walk_inputs(): dfs_version_references.append(v) if caller: caller.step() # pop the first element which is the current scene dfs_version_references.pop(0) caller.end_progress() # register a new caller caller = pdm.register( len(dfs_version_references), '%s.check_referenced_versions()' % self.__class__.__name__ ) # iterate back in the list for v in reversed(dfs_version_references): # check inputs first to_be_updated_list = [] for ref_v in v.inputs: if not ref_v.is_latest_published_version(): to_be_updated_list.append(ref_v) if to_be_updated_list: action = 'create' # check if there is a new published version of this version # that is using all the updated versions of the references latest_published_version = v.latest_published_version if latest_published_version and \ not v.is_latest_published_version(): # so there is a new published version # check if its children needs any update # and the updated child versions are already # referenced to the this published version if all([ref_v.latest_published_version in latest_published_version.inputs for ref_v in to_be_updated_list]): # so all new versions are referenced to this published # version, just update to this latest published version action = 'update' else: # not all references are in the inputs # so we need to create a new version as usual # and update the references to the latest versions action = 'create' else: # nothing needs to be updated, # so check if this version has a new version, # also there could be no reference under this referenced # version if v.is_latest_published_version(): # do nothing action = 'leave' else: # update to latest published version action = 'update' # before setting the action check all the inputs in # resolution_dictionary, if any of them are update, or create # then set this one to 'create' if any(rev_v in reference_resolution['update'] or rev_v in reference_resolution['create'] for rev_v in v.inputs): action = 'create' # so append this v to the related action list reference_resolution[action].append(v) # from stalker import Version # assert isinstance(v, Version) caller.step(message=v.nice_name) caller.end_progress() return reference_resolution