Ejemplos de GStep en Python

Ejemplo n.º 1

Archivo: GNode.py Proyecto: pombredanne/recipe

	def __init__(self,step,recipe):
		TreeNode.__init__(self,step,recipe)
		self.gstep = GStep(step)

Ejemplo n.º 2

Archivo: GNode.py Proyecto: pombredanne/recipe

class GNode(TreeNode):
	def __init__(self,step,recipe):
		TreeNode.__init__(self,step,recipe)
		self.gstep = GStep(step)

	def produce(self,step,recipe):
		return GNode(step,recipe)

	#calculates node length
	def findWidth(self,renderer):
		return self.gstep.w
	
	#calculates node height
	def findHeight(self,renderer):
		return self.gstep.h

	#finds farthest leaf of each node
	def findFarthestLeafs(self, renderer):
		self.farthest_leaf = self
		self.farthest_leaf_dist = 0
		for i in self.children:
			i.findFarthestLeafs(renderer)
		for i in self.children:	
			if i.farthest_leaf_dist + i.findWidth(renderer) > self.farthest_leaf_dist:
				self.farthest_leaf = i.farthest_leaf
				self.farthest_leaf_dist = i.farthest_leaf_dist + i.findWidth(renderer)

	#divide children into up and down ones
	def partitionChildren(self,renderer):
		prev_node = 0
		current_node = self.farthest_leaf
		while prev_node != self:
			#partition children list into up and down list
			#and specify predcessor
			current_node.predcessor = prev_node
			current_node.upper_children = []
			current_node.lower_children = []
			for k in range(len(current_node.children)):
				if current_node.children[k] != current_node.predcessor:
					if k%2 == 0:
						current_node.upper_children.append(current_node.children[k])
					else:
						current_node.lower_children.append(current_node.children[k])
			
			for k in current_node.children:
				if k != current_node.predcessor:
					k.partitionChildren(renderer)

			#move one step up
			prev_node = current_node
			current_node = current_node.parent
	
	#finds all up and down spaces of node
	def findSpaces(self,renderer):
		self.down_space = renderer.v_padding
		self.up_space = renderer.v_padding + self.findHeight(renderer)

		up = 0
		for x in self.upper_children:
			x.findSpaces(renderer)
			up = up + x.up_space + x.down_space
		
		down = 0
		for x in self.lower_children:
			x.findSpaces(renderer)
			down = down + x.down_space + x.up_space

		if self.predcessor != 0:
			self.predcessor.findSpaces(renderer)
			self.up_space = up + max(self.predcessor.up_space, renderer.v_padding + self.findHeight(renderer))
			self.down_space = down + max(self.predcessor.down_space, renderer.v_padding)
	
	#setters
	def setX(self,x):
		self.x = x
		self.gstep.x = x
		
	def setY(self,y):
		self.y = y
		self.gstep.y = y
		
	def setColor(self,color):
		self.color = color
		self.gstep.setColor(color)

	#calculates x coordinate 
	def findX(self,renderer):
		self.setX(0)
		if len(self.children) != 0:
			for c in self.children:
				c.findX(renderer)
				self.x = max(self.x, c.x + c.findWidth(renderer))
			self.setX(self.x + 2*renderer.h_padding)

	def findY(self,renderer,y = "def"):
		if y == "def":
			y = self.down_space
		self.setY(y)
		if self.predcessor != 0:
			up = y + self.predcessor.up_space
			down = y - self.predcessor.down_space
			self.predcessor.findY(renderer,y)

		for c in self.upper_children:	
			up += c.down_space
			c.findY(renderer,up)
			up += c.up_space

		for c in self.lower_children:
			down -= c.up_space
			c.findY(renderer,down)
			down -= c.down_space
	
	def findColor(self, renderer):	
		if self.parent:
			if self == self.parent.predcessor:
				self.setColor(self.parent.color)
			else:
				self.setColor(renderer.giveColor())
		else:
			self.setColor(renderer.giveColor())
		
		for k in self.children:
			k.findColor(renderer)
		

	#draws node
	def draw(self,renderer):
		self.gstep.draw(renderer)