Пример #1
0
	def __addActionsToMenuBar( self, tree, parent ):

		entityId = tree.getCurrentItemId()
		if entityId:
			entity = Hammer.getEntity( entityId )
			actions = Hammer.getActions( entity )
			arg = {}

			parent.clean()
			if actions:
				for action in actions:
					parent.add( Anvil.core.Button(name=action.__name__, cmd=Forge.core.Process.partial( action, entity, arg, self ), w=110) )
Пример #2
0
		def listParentName( entity ):
			parent = Hammer.getEntity( entity['parentId'] )
			self.path.append( parent['name'] + '/' )

			if parent['entityType'] in ['Show', 'BaseEntity']:
				return
			listParentName( parent )
Пример #3
0
	def __addActionsToMenuBar( self, tree, parent ):

		entityId = tree.getCurrentItemId()
		itemName = tree.getCurrentItemName()
		version = eval( itemName.split( ':' )[0] )

		if entityId:
			entity = Hammer.getEntity( entityId )
			entity.setVersion( version=version )
			actions = Hammer.getActions( entity, 'Version' )
			actions += Hammer.getActions( entity )
			arg = {}

			parent.clean()
			if actions:
				for action in actions:
					if action.__name__ in [ 'approved', 'setCurrent', 'openScene', 'openSourceScene', 'get' ]:
						parent.add( Anvil.core.Button(name=action.__name__, cmd=Forge.core.Process.partial( action, entity, arg, self ), w=110) )
Пример #4
0
	def _doAction( self, entity, arg, ui ):

		import nuke
		import Hammer

		self.returnValue = []
		entitiesInfo = Hammer.Hnuke.Actions.GetEntitiesInfoFromScene( entity=entity, arg=arg, ui=ui ).returnValue

		for entityInfo in entitiesInfo:
			currentEntityId = entityInfo.knob('entityId').value()

			self.returnValue.append( Hammer.getEntity(currentEntityId) )
Пример #5
0
    def _doAction(self, entity, arg, ui):

        import maya.cmds
        import Hammer

        self.returnValue = []
        entitiesInfo = Hammer.Hmaya.Actions.GetEntitiesInfoFromScene(entity=entity, arg=arg, ui=ui).returnValue

        for entityInfo in entitiesInfo:
            currentEntityId = maya.cmds.getAttr("%s.entityId" % (entityInfo))

            self.returnValue.append(Hammer.getEntity(currentEntityId))
Пример #6
0
		def setHierarchyList( childrenIds, parentId ):
			for childrenId in childrenIds:
				child = Hammer.getEntity( childrenId )
				entityType = child.getType()

				parent = None
				if parentId:
					parent = Hammer.getEntity( parentId ).getName()

				hierarchyList.append( 	{
										'name':child.getName(),
										'id':childrenId,
										'iconPath':'../core/icon/%s%s.png' %( entityType[0].lower(), entityType[1:] ),
										'tooltip':'%s | entityId:%s, name:%s, assetId:%s' %( child.getType(), child.getEntityId(), child.getName(), child.getAssetId() ),
										'iconTooltip':'type:%s' %( child.getType() ),
										'parent':parent,
										'parentId':parentId,
										} )

				subChildren = child.getChildrenId()
				child.getParentId()
				if subChildren:
					setHierarchyList( subChildren, childrenId )
Пример #7
0
	def editEntity( self, entityId, version=None, approved=None ):
		import Hammer

		entity = Hammer.getEntity( entityId )

		newVersion = entity['version']
		if version:
			newVersion = version

		newApproved = entity['approved']
		if approved:
			newApproved = approved

		# define data
		with open( self.db, 'r' ) as file:
			data = file.readlines()

		# grab entity
		entityLine = self.__getDbLine( entity['entityId'] )

		data[entityLine] = str({
					'entityId':entity['entityId'],
					'name':entity['name'],
					'type':entity['entityType'],
					'path':entity['path'],
					'version':newVersion,
					'descriptions':entity['descriptions'],
					'approved':newApproved,
					'currentUser':entity['currentUser'],
					'parentId':entity['parentId'],
					'childrenId':entity['childrenId'],
					'copyId':entity['copyId'],
					'referenceId':entity['referenceId'],
					'assetId':entity['assetId'],
					'masterAssetId':entity['masterAssetId'],
					'dependencyId':entity['dependencyId'],
					'bundleId':entity['bundleId'],
					'sources':entity['sources'],
					}) + '\n'

		with open( self.db, 'w' ) as file:
			file.writelines( data )
Пример #8
0
	def upFolder( arg ):
		import Hammer

		if arg._currentEntityId != 1:
			# set current entityId to parentId
			entity = Hammer.getEntity( arg._currentEntityId )
			arg._currentEntityId = entity.getParentId()


			# remove last folder in the urlPath field
			folders = arg.textfield_urlPath.getValue().split( '/' )
			for i in [0,-2,-1]:
				del folders[i]

			path = '/'
			for folder in folders:
				path += '%s/' %(folder)

			arg.textfield_urlPath.setValue( path )

			# rebuild tree
			arg._buildTreeEntity( entityIdOverride=True )
Пример #9
0
	def _buildTreeEntity( self, entityIdOverride=False ):

		if not entityIdOverride:
			self._currentEntityId = self.__getEntityIdFromPath()

		entity = Hammer.getEntity( self._currentEntityId )

		hierarchyList = []

		def setHierarchyList( childrenIds, parentId ):
			for childrenId in childrenIds:
				child = Hammer.getEntity( childrenId )
				entityType = child.getType()

				parent = None
				if parentId:
					parent = Hammer.getEntity( parentId ).getName()

				hierarchyList.append( 	{
										'name':child.getName(),
										'id':childrenId,
										'iconPath':'../core/icon/%s%s.png' %( entityType[0].lower(), entityType[1:] ),
										'tooltip':'%s | entityId:%s, name:%s, assetId:%s' %( child.getType(), child.getEntityId(), child.getName(), child.getAssetId() ),
										'iconTooltip':'type:%s' %( child.getType() ),
										'parent':parent,
										'parentId':parentId,
										} )

				subChildren = child.getChildrenId()
				child.getParentId()
				if subChildren:
					setHierarchyList( subChildren, childrenId )

		setHierarchyList( entity.getChildrenId(), None )

		# tree init
		self.tree_hierarchy.add( hierarchyList )
Пример #10
0
	def _buildTreeEntity( self, entityId ):

		entity = Hammer.getEntity( entityId )

		hierarchyList = []

		# versions init
		for version in range( len(entity['approved']) ):
			version = version + 1

			if entity['approved'][version]:
				iconType = 'approved'
			else:
				iconType = 'unapproved'

			if version == entity['version']:
				iconType += 'Actif'

			source = ''
			if entity['source']:
				source = entity['source'][version]


			hierarchyList.append( 	{
									'name':' %i : %s' %( version, entity['descriptions'][version] ),
									'id':entity['entityId'],
									'iconPath':'../core/icon/%s.png' %( iconType ),
									'tooltip':'source : %s ' %(source),
									'iconTooltip':'',
									'parent':None,
									'parentId':None,
									} )


		# tree init
		self.tree_hierarchy.add( hierarchyList )
Пример #11
0
		def listAllChildren( parentId ):
			childrens = Hammer.getEntity( parentId ).getChildrenId()
			if childrens:
				for children in childrens:
					childrenList.append( children )
					listAllChildren( children )
Пример #12
0
	def menuBar( self, tree ):
		entityId = tree.getCurrentItemId()
		if entityId:
			entity = Hammer.getEntity( entityId )
			print entity.getName()
Пример #13
0
		def checkMatch( entityId, name ):
			childrenIds = Hammer.getEntity( entityId ).getChildrenId()
			for childrenId in childrenIds:
				if Hammer.getEntity( childrenId ).getName() == name:
					return childrenId
			return None
Пример #14
0
Here, se see that there are two *instance* attributes: `is_tool` and `tool_type`. The class `Tool` specifies that any `Tool` will have the value `True` for `is_tool` and `None` for `tool_type`, as this is the more general class.

There's also the `Tool` method `use_tool`, which, for a given instance, when executed will print `'Using tool.'`

As previously, we can initialize a `Tool` type object, storing it in `my_tool`. We can then access the attributes of `Tool` and carry out any `Tool` methods:

# access attribute
my_tool = Tool()
my_tool.is_tool

# use method
my_tool.use_tool()

However, what we're most interested in here is the concept of **inheritance**. In the code below, we see how you can inherit `Tool` properties within a new `class` object `Hammer`.

By passing `Tool` in when creating the `class` `Hammer`, `Hammer`-type objects will have the attributes and methods specifed within `Tool`.

We also see with the code here that we're specifying that `tool_type` for a `Hammer` will be `'Hammer'` and provide an additional instance attribute `why`, giving the `Hammer` a purpose - `'To hammer things.'`

class Hammer(Tool): #inherit Tool class
    
    def __init__(self):        
        self.tool_type = 'Hammer'
        self.why = 'To hammer things.'

We can now create a `Hammer`-type object and use the methods from `Tool` - such as `use_tool`- since that is inherited.

# Hammer has Tool attributes and methods
my_hammer = Hammer()
my_hammer.use_tool()

And, we can also access the `Hammer`-specific attributes:

# Hammer has Hammer attributes
my_hammer.why

However, you'll note that `Hammer` does *not* have access to the *attributes* from `Tool`:

# this code will error
my_hammer.is_tool

This is becuase our `Hammer` `class` defines its own *instance attributes*, overriding the instance attributes of the inherited class. We'll see in just a second how to avoid this using `super()`.

Further, note that inheritance is a one-way street. If you created a `Tool` class object (which is the parent class here) and does *not* inherit from `Hammer`, it only has access to `Tool` attributes and methods, so the following would execute without issue:

# Tool objects only have Tool attributes & methods
my_tool = Tool()
my_tool.is_tool

However, if you tried to access the `why` attribute on a `Tool` type object, you would encounter an `AttributeError`, as there is no attribute `why` in the `Tool` class object:

# Tool does NOT inherit from Hammer
# this code will produce an error
my_tool.why

Note in the example above that `tool_type` of `Hammer` class overrides the `tool_type` specified in the `Tool` class that it inherits. The `class` definition can and will override attributes and methods defined in the Parent class.

### `super()`

`super()` allows you to refer to the inherited, parent class, without naming it specifically.

This is particularly helpful when you want to extend the functionality of a class from which you are inheriting.

In the example above, we inherited from `Tool` in our `Hammer` definition and saw that while the `Tool` method were availalbe, the `Tool` instance attraibutes were *not*, due to the fact that our `Hammer` definition had overridden the `Tool` instance attribute definition. 

So...how do we avoid that? This is where `super()` comes in. In the example below, we've added a single line of code (`super().__init__()`) to our `Hammer` definition from above. This specifies that we want to inherit the instance attributes from our parent class `Tool`.

class Hammer(Tool): #inherit Tool class