externalized most scripts

Author: function-store

modules/release/FunctionStore_tools_2023.tox

@@ -0,0 +1,77 @@
+class AltSelectExt:
+	"""
+	AltSelectExt description
+	"""
+	def __init__(self, ownerComp):
+		# The component to which this extension is attached
+		self.ownerComp = ownerComp
+		self.lastSelectedPos = (0, 0)
+		self.family_to_selectpar = {
+			'SOP':'sop',
+			'TOP':'top',
+			'CHOP':'chops',
+			'DAT':'dat',
+			'COMP':'selectpanel'
+		}
+		self.selectColor = (0.71, 0.53, 0.16)
+		self.lastSelectedPos = None
+			
+
+	def OnSelectOP(self, _op):
+		if _op:
+			self.lastSelectedPos = {'op_pos': (_op.nodeX, _op.nodeY), 'docked_pos': {_dock: (_dock.nodeX, _dock.nodeY) for _dock in _op.docked}}
+
+
+	@property
+	def hotkey(self) -> bool:
+		return bool(self.ownerComp.op('null_hk')[0].eval())
+
+
+	def OnUpdate(self, _op: OP):
+		if not self.hotkey:
+			return
+		
+		new_pos = (_op.nodeX, _op.nodeY)
+		if self.lastSelectedPos and (new_pos != self.lastSelectedPos):
+			self.onPosChange(_op, new_pos, self.lastSelectedPos)
+
+
+	def onPosChange(self, _op, new_pos, last_pos):
+		if _op.family not in self.family_to_selectpar.keys():
+			self.lastSelectedPos = None
+			return
+		# selectCOMP only works with Panel types
+		if isinstance(_op, COMP) and not _op.isPanel:
+			self.lastSelectedPos = None
+			return
+		
+		ui.undo.startBlock('Selecting OP') #---------
+
+		sel_par = self.family_to_selectpar[_op.family]
+		sel_fam = _op.family
+
+		new_select = _op.parent().create(f'select{sel_fam}', 
+				   f"select_{_op.name.split('_')[-1]}")
+		new_select.nodeX = new_pos[0]
+		new_select.nodeY = new_pos[1]
+		new_select.par[sel_par] = _op
+		new_select.viewer = True
+		new_select.color = self.selectColor
+		_op.selected = False
+		new_select.selected = True
+		new_select.current = True
+
+		# I usually have this enabled anyway
+		if _op.isPanel:
+			new_select.par.matchsize = True
+
+		ui.undo.endBlock() # -------------------------
+
+		# restore pos
+		_op.nodeX = last_pos['op_pos'][0]
+		_op.nodeY = last_pos['op_pos'][1]
+
+		for _dock in _op.docked:
+			if _dock in last_pos['docked_pos'].keys(): 
+				_dock.nodeX = last_pos['docked_pos'][_dock][0]
+				_dock.nodeY = last_pos['docked_pos'][_dock][1]

modules/suspects/FunctionStore_tools_2023.tox

@@ -0,0 +1,39 @@
+"""
+Extension classes enhance TouchDesigner components with python. An
+extension is accessed via ext.ExtensionClassName from any operator
+within the extended component. If the extension is promoted via its
+Promote Extension parameter, all its attributes with capitalized names
+can be accessed externally, e.g. op('yourComp').PromotedFunction().
+
+Help: search "Extensions" in wiki
+"""
+
+from TDStoreTools import StorageManager
+import TDFunctions as TDF
+
+class AutoCombineExt:
+	"""
+	AutoCombineExt description
+	"""
+	def __init__(self, ownerComp):
+		# The component to which this extension is attached
+		self.ownerComp = ownerComp
+
+	def SetCombine(self, _op):
+		if not _op.inputs:
+			return
+		if self.ownerComp.op('null_hk')['activate'].eval():
+			if _op.pars('combineinput'):
+				try:
+					_op.par.combineinput.val = parent.AutoCombine.par.Combineinput.eval()
+					_op.par.operand.val = parent.AutoCombine.par.Operand.eval()
+				except:
+					pass
+			if _op.pars('rgb'):
+				try:
+					_op.par.rgb.val = parent.AutoCombine.par.Rgb.eval()
+				except:
+					pass
+			if _op.pars('format'):
+				_op.par.format.val = parent.AutoCombine.par.Format.eval()
+		pass

modules/suspects/FunctionStore_tools_2023/AltSelect.tox

@@ -0,0 +1,50 @@
+"""
+Extension classes enhance TouchDesigner components with python. An
+extension is accessed via ext.ExtensionClassName from any operator
+within the extended component. If the extension is promoted via its
+Promote Extension parameter, all its attributes with capitalized names
+can be accessed externally, e.g. op('yourComp').PromotedFunction().
+
+Help: search "Extensions" in wiki
+"""
+
+from TDStoreTools import StorageManager
+import TDFunctions as TDF
+
+class AutoResExt:
+	"""
+	AutoResExt description
+	"""
+	def __init__(self, ownerComp):
+		# The component to which this extension is attached
+		self.ownerComp = ownerComp
+
+	def SetRes(self, _op):
+		if self.ownerComp.op('null_hk')['activate'].eval() and _op.pars('outputresolution'):
+			if not _op.inputs:
+				if _op.par.outputresolution.enable and not _op.isFilter:
+					
+					parentPanel = False
+					i = 1
+					try:
+						while not parentPanel:
+							parentPanel = _op.parent(i).isPanel
+							i += 1						
+					except:
+						pass
+					if parentPanel:
+							_op.par.outputresolution.val = 10
+					else:
+						_op.par.outputresolution.val = 9
+						_op.par.resolutionw.expr = "tdu.tryExcept(lambda: parent.Project.width, op.AUTO_RES.par.Resolutionw)"
+						_op.par.resolutionh.expr = "tdu.tryExcept(lambda: parent.Project.height, op.AUTO_RES.par.Resolutionh)"						
+					
+					if _op.pars('rgb'):
+						try:
+							_op.par.rgb.val = parent.AutoRes.par.Rgb.eval()
+						except:
+							pass
+					if _op.pars('format'):
+						_op.par.format.val = parent.AutoRes.par.Format.eval()
+					
+		pass

modules/suspects/FunctionStore_tools_2023/AutoCombine.tox

@@ -0,0 +1,44 @@
+
+class ClearParsExt:
+	"""
+	ClearParsExt description
+	"""
+	def __init__(self, ownerComp):
+		# The component to which this extension is attached
+		self.ownerComp = ownerComp
+		self.Op = None 
+
+	def ClearPars(self):
+		
+		_ops = [self.Op]
+		
+		if self.ownerComp.par.Recursive.eval():
+			if _op := _ops[0]:
+				if _op.isCOMP:
+					_ops.extend(_op.findChildren(depth=1, includeUtility=False, key=lambda _o: _o.opType != 'annotateCOMP' and 'annotate' not in _o.name))
+			
+		ui.undo.startBlock('Clear Par Errors')
+		for _op in _ops:
+			if _op is None:
+				continue
+			for _par in _op.pars():
+				if _par.name == 'autoexportroot' or 'expr' in _par.name:
+					continue
+				if _par.valid:
+					if _par.mode == ParMode.BIND:
+						if _par.bindMaster == None:
+							_par.bindExpr = None
+							_par.expr = None
+							_par.mode = ParMode.CONSTANT
+							pass
+					if _par.mode == ParMode.EXPRESSION:
+						try:
+							_par.eval()
+						except:
+							_par.expr = None
+							_par.bindExpr = None
+							_par.mode = ParMode.CONSTANT
+			
+			if _op.isCOMP and _op.opType != annotateCOMP:
+				_op.clearScriptErrors(recurse=True)
+		ui.undo.endBlock()