def LoadActions(self):
""" parses the definition specific actions """
Logger.info(u'Loading Actions for definition:' + self.uDefPublicTitle)
SetDefinitionContext(self.uName)
if Globals.oFnAction.Exists():
sET_Data = CachedFile(Globals.oFnAction)
sET_Data = ReplaceDefVars(sET_Data, self.oDefinitionVars)
oET_Root = Orca_FromString(sET_Data, self,
Globals.oFnAction.string)
Orca_include(oET_Root, orca_et_loader)
SetDefinitionContext(self.uName)
Globals.oActions.LoadActionsSub(oET_Root, u'pagestartactions',
u'pagestartaction',
Globals.oActions.dActionsPageStart,
Globals.oFnAction)
Globals.oActions.LoadActionsSub(oET_Root, u'pagestartactions',
u'pagestopaction',
Globals.oActions.dActionsPageStop,
Globals.oFnAction)
Globals.oActions.LoadActionsSub(oET_Root, u'actions', u'action',
Globals.oActions.dActionsCommands,
Globals.oFnAction)
SetVar(uVarName=u'ORCASTANDARDPAGESTARTACTIONSINCLUDED',
oVarValue=u"1")
SetVar(uVarName=u'ORCASTANDARDACTIONSINCLUDED', oVarValue=u"1")
RestoreDefinitionContext()
return
def LoadScriptList(self, oPath=None):
""" loads a list of all scripts """
if oPath is None:
oPath = Globals.oPathScripts
if oPath == Globals.oPathScripts:
Logger.debug(u'Scripts: Loading Script List')
aScriptNameList = oPath.GetFolderList()
for uScriptNameFolder in aScriptNameList:
oFolderPath = cPath(oPath) + uScriptNameFolder
if (cFileName(oFolderPath) + "script.py").Exists():
self.aScriptNameList.append(uScriptNameFolder)
self.dScriptPathList[uScriptNameFolder] = oFolderPath
else:
self.LoadScriptList(oPath=oFolderPath)
if oPath == Globals.oPathScripts:
self.aScriptNameList.sort(key=lambda x: x)
for uScriptName in self.aScriptNameList:
SetVar(uVarName="SCRIPTPATH[%s]" % uScriptName,
oVarValue=self.dScriptPathList[uScriptName].string)
oPathScriptSkinElements = self.dScriptPathList[
uScriptName] + "elements"
oPathCheck = oPathScriptSkinElements + ("skin_" +
Globals.uSkinName)
if oPathCheck.Exists():
oPathScriptSkinElements = oPathCheck
else:
oPathScriptSkinElements = oPathScriptSkinElements + "skin_default"
SetVar(uVarName="SCRIPTPATHSKINELEMENTS[%s]" % (uScriptName),
oVarValue=oPathScriptSkinElements.string)
def InitOrientationVars(self):
"""
Getting the orientation of the App and sets to system vars for it
"""
# noinspection PyProtectedMember
Logger.debug(
u'Setting Orientation Variables #1: Screen Size: [%s], Width: [%s], Heigth: [%s], Orientation: [%s]'
%
(str(Globals.fScreenSize), str(self._app_window._size[0]),
str(self._app_window._size[1]), str(Globals.uDeviceOrientation)))
OS_GetWindowSize()
if Globals.iAppWidth < Globals.iAppHeight:
Globals.uDeviceOrientation = 'portrait'
else:
Globals.uDeviceOrientation = 'landscape'
Globals.oRotation.Lock()
SetVar(uVarName=u'DEVICEORIENTATION',
oVarValue=Globals.uDeviceOrientation)
SetVar(uVarName=u'SCREENSIZE', oVarValue=str(Globals.fScreenSize))
Logger.debug(
u'Setting Orientation Variables: Screen Size: [%s], Width: [%s], Heigth: [%s], Orientation: [%s]'
% (str(Globals.fScreenSize), str(Globals.iAppWidth),
str(Globals.iAppHeight), str(Globals.uDeviceOrientation)))
def On_ConfigChange(self, oSettings: KivySettings,
oConfig: KivyConfigParser, uSection: str, uKey: str,
uValue: str):
""" reacts, if user changes a setting """
if uKey == u'configchangebuttons':
self.uCurrentSection = uSection
if uValue == u'button_add':
SetVar(uVarName=u'SCRIPTINPUT', oVarValue=u'DEVICE_dummy')
self.oInputKeyboard = ShowKeyBoard(uDestVar=u'SCRIPTINPUT',
oFktNotify=self.On_InputAdd)
if uValue == u'button_delete':
ShowQuestionPopUp(uTitle=u'$lvar(5003)',
uMessage=u'$lvar(5044)',
fktYes=self.On_InputDel,
uStringYes=u'$lvar(5001)',
uStringNo=u'$lvar(5002)')
if uValue == u'button_rename':
SetVar(uVarName=u'SCRIPTINPUT', oVarValue=uSection)
self.oInputKeyboard = ShowKeyBoard(uDestVar=u'SCRIPTINPUT',
oFktNotify=self.On_InputRen)
else:
oSetting = self.oObject.GetSettingObjectForConfigName(
uConfigName=uSection)
if uKey in self.dSettingsCombined:
uType = self.dSettingsCombined[uKey].get("type")
if uType == "numeric" or uType == "numericslider":
oSetting.aIniSettings[uKey] = ToInt(uValue)
elif uType == "numericfloat":
oSetting.aIniSettings[uKey] = ToFloat(uValue)
elif uType == "bool":
oSetting.aIniSettings[uKey] = ToBool(uValue)
else:
oSetting.aIniSettings[uKey] = uValue
def On_Definition_ConfigChange(self, settings, config, section, key,
value):
""" Called, when a setting has been changed, will set the associated var as well """
if key in Globals.oDefinitions.aDefinitionSettingVars:
if value.startswith("button_"):
SetVar(uVarName=key, oVarValue=str(random()))
else:
SetVar(uVarName=key, oVarValue=value)
def LoadXMLFile(self) -> bool:
""" The main function to load the xml """
SetDefinitionContext(uDefinitionName=self.uName)
Globals.oTheScreen.LogToSplashScreen2(uText=self.uDefDescription)
Logger.info(u'Loading definition XmlFile:' +
Globals.oDefinitionPathes.oFnDefinition)
oET_Root: Element = self.oET_Root
try:
Logger.debug(u'Definition %s (%s): Loading xml includes' %
(self.uName, self.uAlias))
Orca_include(
oElem=oET_Root,
pLoader=orca_et_loader,
uFileName=Globals.oDefinitionPathes.oFnDefinition.string)
SetDefinitionContext(uDefinitionName=self.uName)
except Exception as e:
StartWait()
ShowErrorPopUp(
uTitle="LoadXMLFile:Fatal Error",
uMessage=LogError(
uMsg=u'Fatal Error: definition xml file faulty:' +
self.uName,
oException=e),
bAbort=True)
SetVar(uVarName='ORCASTANDARDPAGESINCLUDED', oVarValue="1")
Globals.oTheScreen.uDefName = self.oRepManEntry.oRepEntry.uName
self.oDefinitions.uDefinitionAuthor = self.oRepManEntry.oRepEntry.uAuthor
self.oDefinitions.uDefinitionVersion = self.oRepManEntry.oRepEntry.uVersion
SetVar(uVarName=u'DEFINITIONAUTHOR',
oVarValue=self.oDefinitions.uDefinitionAuthor)
SetVar(uVarName=u'DEFINITIONVERSION',
oVarValue=self.oDefinitions.uDefinitionVersion)
SetVar(uVarName=u'DEFINITIONSUPPORT',
oVarValue=self.oDefinitions.uDefinitionSupport)
Logger.debug(u'Definition [%s] : Ratios %fx%f:' %
(self.uName, self.fRationX, self.fRationY))
if self.bImportPages:
# get a list of all pages and add Them
oXMLPages: Element = oET_Root.find('pages')
for oXMLPage in oXMLPages.findall('page'):
Globals.oTheScreen.oScreenPages.AddPageFromXmlNode(
oXMLPage=oXMLPage)
oXMLPageImport: Element = oXMLPages.find('pageimport')
if oXMLPageImport is not None:
for oXMLPage in oXMLPageImport.findall('page'):
Globals.oTheScreen.oScreenPages.AddPageFromXmlNode(
oXMLPage=oXMLPage)
Globals.oNotifications.SendNotification(
uNotification="DEFINITIONPAGESLOADED", **{"definition": self})
RestoreDefinitionContext()
return True
def AppendToPageQueue(self, oPage):
""" Appends a Page to the list of last shown pages"""
if GetVar(uVarName=u'FIRSTPAGE') == u'':
SetVar(uVarName=u'FIRSTPAGE', oVarValue=oPage.uPageName)
SetVar(uVarName=u'CURRENTPAGE', oVarValue=oPage.uPageName)
self.aPageQueue.append(oPage)
if len(self.aPageQueue) > 1:
SetVar(uVarName=u'LASTPAGE',
oVarValue=self.aPageQueue[-2].uPageName)
def InvertSwitch(self, instance: Union[cTouchButton, None]) -> None:
""" Inverts and button and the var """
if GetVar(uVarName=self.uDestVar) == '1':
SetVar(uVarName=self.uDestVar, oVarValue='0')
self.SetPictureNormal(self.oFnButtonPictureNormalOrg.string, True)
self.SetPicturePressed(self.oFnButtonPicturePressedOrg.string)
else:
SetVar(uVarName=self.uDestVar, oVarValue='1')
self.SetPictureNormal(self.oFnButtonPicturePressedOrg.string, True)
self.SetPicturePressed(self.oFnButtonPictureNormalOrg.string)
def AssignChannels(self, **kwargs):
"""
Sets the TV Logos for the parsed channels
:param kwargs: argument dic, need to have definitionalias, interface, configname, force
"""
try:
uAlias = ReplaceVars(kwargs['definitionalias'])
uInterfaceName = ReplaceVars(kwargs['interface'])
uConfigName = ReplaceVars(kwargs['configname'])
bForce = ReplaceVars(kwargs['force']) != '0'
oInterFace = Globals.oInterFaces.dInterfaces.get(uInterfaceName)
oSetting = oInterFace.GetSettingObjectForConfigName(uConfigName)
uContext = oSetting.uContext
uSection = Globals.uDefinitionName
dServices = self.dServices.get(uContext, {})
aBouquets = dServices.get("Bouquets", [])
for dBouquetDetail in aBouquets:
iBouquetNumber = dBouquetDetail["BouquetNum"]
if iBouquetNumber < 5:
uBouquetName = dBouquetDetail["Name"]
uVarName = uAlias + "_bouquet_name[" + str(
iBouquetNumber) + "]"
uVarValue = uBouquetName
Globals.oDefinitionConfigParser.set(
uSection, uVarName, EscapeUnicode(uVarValue))
SetVar(uVarName=uVarName, oVarValue=uVarValue)
dChannels = dBouquetDetail.get("Channels", {})
for iBouquetChannelNum in dChannels:
if iBouquetChannelNum < 30:
dChannel = dChannels[iBouquetChannelNum]
uVarName = uAlias + "%s[%d][%d]" % (
"_tvlogo", iBouquetNumber, iBouquetChannelNum)
if Globals.oDefinitionConfigParser.get(
uSection,
uVarName) == "discover" or bForce:
uVarValue = self.FindChannelLogo(
dChannel["ChannelName"])
Globals.oDefinitionConfigParser.set(
uSection, uVarName,
EscapeUnicode(uVarValue))
SetVar(uVarName=uVarName, oVarValue=uVarValue)
uVarName = uAlias + "%s[%d][%d]" % (
"_tvchannel", iBouquetNumber,
iBouquetChannelNum)
uVarValue = str(dChannel["ChannelNum"])
Globals.oDefinitionConfigParser.set(
uSection, uVarName, uVarValue)
SetVar(uVarName=uVarName, oVarValue=uVarValue)
Globals.oDefinitionConfigParser.write()
except Exception as e:
self.ShowError("Can''t assign channelnumbers", e)
def On_Color_Wheel(self, *largs):
""" updates the deasvars, of the colorpicker color has changed """
instance=self.oObjectColorPicker
self.fValue = instance.hex_color
if self.uDestVar:
SetVar(uVarName = self.uDestVar, oVarValue = self.fValue )
SetVar(uVarName = self.uDestVar+"_hex", oVarValue = self.fValue )
h,s,v=instance.hsv[0],instance.hsv[1],instance.hsv[2]
SetVar(uVarName = self.uDestVar+"_h", oVarValue = str(int(h*255)))
SetVar(uVarName = self.uDestVar+"_s", oVarValue = str(int(s*255)))
SetVar(uVarName = self.uDestVar+"_v", oVarValue = str(int(v*255)))
SetVar(uVarName = self.uDestVar+"_r", oVarValue = str(int(instance.color[0]*255) ))
SetVar(uVarName = self.uDestVar+"_g", oVarValue = str(int(instance.color[1]*255) ))
SetVar(uVarName = self.uDestVar+"_b", oVarValue = str(int(instance.color[2]*255) ))
SetVar(uVarName = self.uDestVar+"_a", oVarValue = str(int(instance.color[3]*255) ))
Logger.debug("Setting Var:"+self.uDestVar+"="+str(self.fValue))
Logger.debug("Setting Var:"+self.uDestVar+"_hex"+"="+str(self.fValue))
Logger.debug("Setting Var:"+self.uDestVar+"_h"+"="+str(str(int(h*255))))
Logger.debug("Setting Var:"+self.uDestVar+"_s"+"="+str(str(int(s*255))))
Logger.debug("Setting Var:"+self.uDestVar+"_v"+"="+str(str(int(v*255))))
Logger.debug("Setting Var:"+self.uDestVar+"_r"+"="+str(int(instance.color[0]*255)))
Logger.debug("Setting Var:"+self.uDestVar+"_g"+"="+str(int(instance.color[1]*255)))
Logger.debug("Setting Var:"+self.uDestVar+"_b"+"="+str(int(instance.color[2]*255)))
Logger.debug("Setting Var:"+self.uDestVar+"_a"+"="+str(int(instance.color[3]*255)))
#SetVar(self.uDestVar+"_rgba",instance.color)
if self.uActionName:
if self.fOldValue != self.fValue:
self.fOldValue = self.fValue
self.On_Button_Up(instance)
def CreateRepVarArray(self,uBaseLocalDir:str) -> None:
aLocalFiles:List[str] = cPath(uBaseLocalDir).GetFileList(bSubDirs=True, bFullPath=True)
SetVar(uVarName="REPMAN_LOCALBASENAME", oVarValue=uBaseLocalDir)
SetVar(uVarName="REPMAN_CNTFILES", oVarValue= str(len(aLocalFiles)))
Var_DelArray("REPMAN_LOCALFILENAMES[]")
i:int=0
for uLocalFile in aLocalFiles:
uIndex:str = str(i) + "]"
SetVar(uVarName="REPMAN_LOCALFILENAMES[" + uIndex ,oVarValue=uLocalFile)
i += 1
def UpdateVars(self) -> None:
""" updates the destination vars """
if not self.uDestVar == u'':
SetVar(uVarName=self.uDestVar, oVarValue=ToUnicode(self.fValue))
if self.oObject:
SetVar(uVarName=self.uDestVar + u'_degree',
oVarValue=ToUnicode(self.oObject.iAngle))
SetVar(uVarName=self.uDestVar + u'_direction',
oVarValue=ToUnicode(self.oObject.uDirection))
SetVar(uVarName=self.uDestVar + u'_absdegree',
oVarValue=ToUnicode(self.iAbsAngle))
def __init__(self, *,uDefinitionName:str, uDefinitionPathName:str=u"") -> None:
uAdd:str
self.oPathDefinition:cPath
self.oPathDefinitionSkinElements:cPath
oPathCheck:cPath
uCheck:str
if Globals.uDeviceOrientation == 'landscape':
uAdd = 'l'
else:
uAdd = 'p'
if Globals.fScreenSize<5.1:
uAdd += 's'
else:
uAdd += 'l'
if uDefinitionPathName==u"":
self.oPathDefinition = Globals.oPathDefinitionRoot + uDefinitionName
else:
self.oPathDefinition = Globals.oPathDefinitionRoot + uDefinitionPathName
self.oPathDefinitionAtlas:cPath = self.oPathDefinition + 'atlas'
self.oFnDefinitionAtlas:cFileName = cFileName(self.oPathDefinitionAtlas) + u'definition.atlas'
self.oFnDefinitionLocalFont:cFileName = cFileName(self.oPathDefinition + u'fonts') + 'fonts.xml'
self.oFnDefinition:cFileName = cFileName(self.oPathDefinition) + u'definition.xml'
self.oFnDefinitionCache:cFileName = cFileName(self.oPathDefinition) + (u'cache_' + uAdd + '.xml')
self.oFnDefinitionIni:cFileName = cFileName(self.oPathDefinition) + u'definition.ini'
self.oPathDefinitionInterfaceSettings:cPath = self.oPathDefinition + u'interfacesettings'
self.oPathDefinitionScriptSettings:cPath = self.oPathDefinition + u'scriptsettings'
self.oFnDefinitionLanguage:cFileName = cFileName()
self.oFnDefinitionLanguageFallBack:cFileName = cFileName(self.oPathDefinition + u'languages/English')+ "strings.xml"
self.oPathDefinitionSkinElements:cPath = self.oPathDefinition + u'elements'
self.oPathTemplateSkinElements:cFileName = cFileName()
uCheck = "skin_" + Globals.uSkinName
oPathCheck = self.oPathDefinitionSkinElements + uCheck
if oPathCheck.Exists():
self.oPathDefinitionSkinElements = oPathCheck
SetVar("SKINCONTEXT",uCheck)
else:
self.oPathDefinitionSkinElements = self.oPathDefinitionSkinElements + "skin_default"
SetVar("SKINCONTEXT", "skin_default")
self.LanguageChange()
if uDefinitionName in Globals.oDefinitions:
if "definition_templatename_mediaplayer_wizard" in Globals.oDefinitions[uDefinitionName].oDefinitionVars:
oPathCheck = Globals.oPathWizardTemplates +(Globals.oDefinitions[uDefinitionName].oDefinitionVars["definition_templatename_mediaplayer_wizard"]+"/elements/" +uCheck)
if oPathCheck.Exists():
self.oPathTemplateSkinElements = oPathCheck
SetVar("MEDIATEMPLATESKINCONTEXT",uCheck)
else:
self.oPathDefinitionSkinElements = Globals.oPathWizardTemplates +(Globals.oDefinitions[uDefinitionName].oDefinitionVars["definition_templatename_mediaplayer_wizard"]+"/elements/" + "skin_default")
SetVar("MEDIATEMPLATESKINCONTEXT", "skin_default")
def On_Orca_ConfigChange(self, settings: Settings, config: ConfigParser,
section: str, key: str, value: str) -> None:
""" Called, when a setting has been changed, will set the associated var as well """
if value.startswith("button_"):
SetVar(uVarName=key, oVarValue=str(random()))
else:
SetVar(uVarName=key, oVarValue=value)
OrcaConfigParser_On_Setting_Change(config=config,
section=section,
key=key,
value=value)
def _SetVar(self,uValue,uDebugMessage,uAddName=u''):
""" Sets the vars, which contains the parse results """
if self.uLocalDestVar != u'':
self.ShowDebug(u'Local: %s : [%s]=[%s]' % (uDebugMessage,self.uLocalDestVar+uAddName,uValue))
SetVar(uVarName = self.uLocalDestVar+uAddName, oVarValue = uValue, uContext = self.uContext)
if self.uGlobalDestVar != u'':
if self.uGlobalDestVar.startswith("$var("):
self.uGlobalDestVar=ReplaceVars(self.uGlobalDestVar)
self.ShowDebug(u'Global: %s : [%s]=[%s]' %(uDebugMessage,self.uGlobalDestVar+uAddName,uValue))
SetVar(uVarName = self.uGlobalDestVar+uAddName, oVarValue = uValue)
SetVar(uVarName = "RESULT", oVarValue = uValue)
SetVar(uVarName = "GLOBALDESTVAR", oVarValue = self.uGlobalDestVar+uAddName)
def SetDefinitionPathes(uDefinitionName, uDefinitionPathName=u''):
"""
Sets the definition pathes to a specific definition
"""
if not uDefinitionName in Globals.dDefinitionPathes:
oDefinitionPathes = cDefinitionPathes(uDefinitionName, uDefinitionPathName)
Globals.dDefinitionPathes[uDefinitionName] = oDefinitionPathes
Globals.oDefinitionPathes = Globals.dDefinitionPathes[uDefinitionName]
SetVar(uVarName=u'DEFINITIONPATH', oVarValue=Globals.oDefinitionPathes.oPathDefinition.string)
SetVar(uVarName=u'DEFINITIONFILENAME', oVarValue=Globals.oDefinitionPathes.oFnDefinition.string)
SetVar(uVarName=u'DEFINITIONNAME', oVarValue=Globals.uDefinitionName)
SetVar(uVarName=u'DEFINITIONPATHSKINELEMENTS', oVarValue=Globals.oDefinitionPathes.oPathDefinitionSkinElements.string)
def Var_Round(uVarName: str, uPos: str) -> str:
"""
Rounds a var value to the given round position.
The changed variable value will be return and stored in the user vars (Triggers raised if set)
Example: Round(1.81,0) return 2. Round(1.81,1) returns 1.80
:param str uVarName: The variable name for the action, from where the value is pulled
:param str uPos: The round position
:return: The changed variable value
"""
uValue: str = GetVar(uVarName=uVarName)
try:
if uValue == u'':
return u''
uPosToUse: str = GetVar(uVarName=uPos)
if uPosToUse == u'':
uPosToUse = uPos
iPos: int = int(uPosToUse)
uValue = ToUnicode(Round(ToFloat(uValue), iPos))
SetVar(uVarName=uVarName, oVarValue=uValue)
return uValue
except Exception as e:
LogError(uMsg=u'Var_Round: Invalid Argument [' + uVarName + u'=' +
uValue + u']:',
oException=e)
return u'Error'
def Var_Power(uVarName: str, uPower: str) -> str:
"""
Exponentiate a given variable value.
The changed variable value will be return and stored in the user vars (Triggers raised if set)
:param str uVarName: The variable name for the action, from where the value is pulled
:param str uPower: The value to exponentiate the original value with, can be a variable itself
:return: The changed variable value
"""
try:
uValue: str = GetVar(uVarName=uVarName)
uValueOrg: str = uValue
if uValue == u'':
return u''
uPowerToUse: str = GetVar(uVarName=uPower)
if uPowerToUse == u'':
uPowerToUse = uPower
uPowerToUse = ReplaceVars(uPowerToUse)
fPower: float = ToFloat(uPowerToUse)
fValue: float = ToFloat(uValue)
fValue = fValue**fPower
uValue = ToUnicode(fValue)
uValue = Var_NormalizeInt(uValue)
SetVar(uVarName=uVarName, oVarValue=uValue)
Logger.debug(
u'Var_Power: [%s] ^ [%s] returned [%s] (stored in [%s])' %
(uValueOrg, uPowerToUse, uValue, uVarName))
return uValue
except Exception as e:
LogError(uMsg=u'Var_Power: Invalid Argument', oException=e)
return u'Error'
def ReplaceElement(self, uFnElement, uReplaceWidgetName, oDefinition):
""" Replaces an element at runtime in a page: the page must not be initalized
:param string uFnElement: FileName of element to load
:param string uReplaceWidgetName: The Widgetname to be replaced
:param cDefinition oDefinition: Target Definition
:rtype: bool
:return: True if successful, otherwise False
"""
uFnFile = ''
try:
uFnFile = (cFileName(u'').ImportFullPath(uFnElement)).string
SetVar(uVarName='ORCA_INCLUDEFILE', oVarValue=uFnFile)
if oDefinition is None:
oDef = self.oWidgetBackGround.oDef
else:
oDef = oDefinition
sET_Data = CachedFile(Globals.oFnElementIncludeWrapper)
sET_Data = ReplaceDefVars(sET_Data, oDef.oDefinitionVars)
oET_Root = Orca_FromString(sET_Data, oDef, uFnFile)
Orca_include(oET_Root, orca_et_loader)
self._ReplaceElements(oXMLNode=oET_Root,
uReplaceWidgetName=uReplaceWidgetName)
return True
except Exception as e:
uMsg = LogError(
"Can''t load element (replace): %s (%s):" %
(uFnElement, uFnFile), e)
ShowErrorPopUp(uMessage=uMsg)
return False
def CallTrigger(self, oTrigger: cBaseTrigger, uResponse: str) -> None:
"""
calls a trigger
:param cBaseTrigger oTrigger: The trigger object
:param str uResponse: The response of the trigger action
:return: None
"""
# if oTrigger.uTriggerAction=='':
# self.ShowWarning(u'No Trigger Action defined for Trigger:' + oTrigger.uTriggerName)
# # return
self.ShowDebug(uMsg=oTrigger.uTriggerName + ":"
u'Trigger Action:' + oTrigger.uTriggerAction)
uCmd: str
vRetVal: Union[str, Tuple]
uRetVal: str
oAction: Union[None, cAction] = None
if oTrigger.uGetVar.startswith(u'codesetcode:'):
uActionName: str = self.MakeLocalActionName(oTrigger.uGetVar[12:])
aActions: List[cAction] = Globals.oActions.GetActionList(
uActionName=uActionName, bNoCopy=False)
if aActions is not None:
oAction = aActions[0]
if oAction.uGetVar != u'':
oTrigger.uGetVar = oAction.uGetVar
if oAction.uGlobalDestVar != u'':
oTrigger.uRetVar = oAction.uGlobalDestVar
oTrigger.uTriggerName = oAction.uCmd
if oAction is None:
if self.oAction:
oAction = copy(self.oAction)
else:
oAction = copy(self.oLastAction)
oAction.uActionName = oTrigger.uTriggerAction
oAction.uGetVar = oTrigger.uGetVar
oAction.uGlobalDestVar = oTrigger.uRetVar
#We call ParseResult to set the Values to proper Global Vars
uCmd, vRetVal = self.oInterFace.ParseResult(oAction, uResponse, self)
if isinstance(vRetVal, tuple):
uRetVal = vRetVal[0]
else:
uRetVal = vRetVal
if oTrigger.uRetVar != u'' and uRetVal != u'':
SetVar(uVarName=oTrigger.uRetVar, oVarValue=uRetVal)
if oAction.uActionName != u'':
aActions = Globals.oEvents.CreateSimpleActionList(
aActions=[{
'string': 'call',
'actionname': oTrigger.uTriggerAction,
'name': oAction.uActionName
}])
Globals.oEvents.ExecuteActionsNewQueue(
aActions, Globals.oTheScreen.oCurrentPage.oWidgetBackGround)
def __init__(self):
oInterFaceTelnet.cInterface.__init__(self)
self.aTargets = {
'0': 'TV',
'1': 'Recording 1',
'2': 'Recording 2',
'3': 'Tuner 1',
'4': 'Playback 1',
'5': 'Audio system',
'6': 'Tuner 2',
'7': 'Tuner 3',
'8': 'Playback 2',
'9': 'Playback 3',
'A': 'Tuner 4',
'B': 'Playback 3',
'C': 'Reserved (C)',
'D': 'Reserved (D)',
'E': 'Reserved (E)',
'F': 'Unregistered'
}
uValueString = u''
for uKey in self.aTargets:
uValueString += u'\"' + self.aTargets[uKey] + u'\",'
uValueString = uValueString[1:-2]
SetVar(uVarName="VALUESTRING", oVarValue=uValueString)
def Var_Int2Hex(uVarName: str, uFormat: str = '{0:0>2X}') -> str:
"""
Converts a Variable which represents an int value to a string of a hex value
The changed variable value will be return and stored in the user vars (Triggers raised if set)
:param str uVarName: The variable name for the action, from where the value is pulled
:param str uFormat: The format to use for the conversion
:return: The changed variable value
"""
uValue: str = GetVar(uVarName=uVarName)
try:
if uValue == '':
return u'0'
if uValue == 'Error':
return u'0'
uValue = uFormat.format(int(uValue))
uValue = ToUnicode(uValue)
SetVar(uVarName=uVarName, oVarValue=uValue)
return uValue
except Exception as e:
LogError(uMsg=u'Var_Int2Hex: Invalid Argument (%s):' % uValue,
oException=e)
return u'0'
def WorkOnQueueDoAction(self, *,
oAction: cAction) -> Union[eReturnCode, int]:
""" Executes a single action in a queue (including condition verifying)"""
eRet: eReturnCode = eReturnCode.Success
bCheckSuccess: bool = CheckCondition(oPar=oAction)
if oAction.iActionId == Globals.oActions.oActionType.If:
# we do the If statement only in case of the condition fails
if bCheckSuccess:
Globals.oEvents.LogAction(uTxt="if",
oAction=oAction,
uAddText="executing actions")
# we need to run the if command in any way to skip the actions
bCheckSuccess = not bCheckSuccess
if bCheckSuccess:
#We set / replace Action Command Pars by Definition/Button pars
eRet = self.ExecuteAction(oAction=oAction)
if eRet != eReturnCode.Nothing:
SetVar(uVarName=u'LASTERRORCODE', oVarValue=ToUnicode(eRet))
if eRet != eReturnCode.Success:
Logger.debug("Action returned LASTERRORCODE " +
ToUnicode(eRet))
return eRet
def InitVars(self) -> None:
""" (re) Initialises all vars (also after a definition change) """
InitSystemVars()
Globals.oDefinitions.InitVars()
SetVar(uVarName = u'REPVERSION', oVarValue = ToUnicode(Globals.iVersion))
# Name of the Current page
# List for settings dialog
self.bIntransition = False
self.dGestures.clear()
self.dPopups.clear()
self.iLastWidgetPage = 0
Globals.oActions.InitVars()
self.oCurrentPage = None
self.oFonts.DeInit()
self.oGdb = GestureDatabase()
self.oPopup = None
self.oScreenPages.DeInit()
self.uCurrentEffect = u''
self.uCurrentEffectDirection = u''
self.uCurrentPageName = u''
self.uDefaultTransmitterPictureName = u''
self.uDefaultWaitPictureName = u''
self.uDefName = u''
self.uFirstPageName = u''
self.uInterFaceToConfig = u''
self.uScriptToConfig = u''
self.uConfigToConfig = u''
self.uSplashText = u''
self.iBlockCount = 0
self.iBlockAskCount = 0
if Globals.oTheScreen:
Globals.oTheScreen.oSkin.dSkinRedirects.clear()
gc.collect()
def Receive(self, uResponse: str):
aActionTrigger: Optional[List[cBaseTrigger]]
uResponse = ToUnicode(uResponse)
if self.oAction is not None:
uCmd, uRetVal = self.oInterFace.ParseResult(
self.oAction, uResponse, self)
self.ShowDebug(uMsg=u'Parsed Responses:' + uRetVal)
if not self.uRetVar == u'' and not uRetVal == u'':
SetVar(uVarName=self.uRetVar, oVarValue=uRetVal)
# We do not need to wait for an response anymore
StartWait(0)
self.oAction = None
else:
oAction: cAction = self.dStandardActions["defaultresponse"]
if oAction:
uCommand = self.oInterFace.ParseResult(
oAction, uResponse, self)
if not isinstance(uCommand, str):
if len(uCommand) > 0:
uCommand = uCommand[1]
# we have a notification issued by the device, so lets have a look, if we have a trigger assigned to it
aActionTrigger = self.GetTrigger(uCommand)
if aActionTrigger is not None:
for oActionTrigger in oActionTrigger:
self.CallTrigger(oActionTrigger, uResponse)
else:
self.ShowDebug(uMsg=u'Discard message:' + uCommand +
':' + uResponse)
def Var_Part(uVarName: str, uStart: str, uEnd: str) -> str:
"""
Extracts a part of a variable value.
The changed variable value will be return and stored in the user vars (Triggers raised if set)
:param str uVarName: The variable name for the action, from where the value is pulled
:param str uStart: The start position within the var value
:param str uEnd: The end position within the var value
:return: The changed variable value
"""
try:
uValue: str = GetVar(uVarName=uVarName)
if uValue == u'':
return u''
if not uStart == '':
if not uEnd == '':
uValue = uValue[int(uStart):int(uEnd)]
else:
uValue = uValue[int(uStart):]
else:
uValue = uValue[:int(uEnd)]
SetVar(uVarName=uVarName, oVarValue=uValue)
return uValue
except Exception as e:
LogError(uMsg='Var_Part: Invalid Argument', oException=e)
return u'Error'
def Var_Hex2Int(uVarName: str) -> str:
"""
Converts a Variable which represents an hex value to a string of an Int value
The changed variable value will be return and stored in the user vars (Triggers raised if set)
:param str uVarName: The variable name for the action, from where the value is pulled
:return: The changed variable value
"""
uValue: str = GetVar(uVarName=uVarName)
try:
if uValue == '':
return u'0'
if uValue == 'Error':
return u'0'
if uValue.lower().startswith('0x'):
iValue = int(uValue, 0)
else:
iValue = int(uValue, 16)
uValue = ToUnicode(iValue)
uValue = Var_NormalizeInt(uValue)
SetVar(uVarName=uVarName, oVarValue=uValue)
return uValue
except Exception as e:
LogError(uMsg=u'Var_Hex2Int: Invalid Argument (%s):' % uValue,
oException=e)
return u'0'
def BuildSettingOptionListVar(aArray: Iterable[str], uDestVar: str) -> str:
"""
Little helper function to create a json option list
"""
uValueString = "[" + BuildSettingOptionList(aArray) + "]"
SetVar(uDestVar, uValueString)
return uValueString
def Var_Format(uVarName: str, uFormat: str):
"""
Formats a variable content to a given format
The changed variable value will be return and stored in the user vars (Triggers raised if set)
:param str uVarName: The variable name for the action, from where the value is pulled
:param str uFormat: The format to use (python syntax)
:return: The changed variable value
"""
try:
uValue: str = GetVar(uVarName=uVarName)
if uValue is None:
return u''
uFormatToUse: str = ORCA.vars.Globals.dUserVars.get(uFormat)
if uFormatToUse is None:
uFormatToUse = uFormat
if uFormatToUse.startswith('(int)'):
uFormatToUse = uFormatToUse[5:]
uValue = uFormatToUse.format(int(ToFloat(uValue)))
elif uFormatToUse.startswith('(float)'):
uFormatToUse = uFormatToUse[7:]
uValue = uFormatToUse.format(ToFloat(uValue))
SetVar(uVarName=uVarName, oVarValue=uValue)
return uValue
except Exception as e:
LogError(uMsg=u'Var_Format: Invalid Argument', oException=e)
return u''
def Var_Find(uVarName, uFindVar, uDestVar):
"""
Finds the posiion of a substring in a variable value.
The changed variable value will be returned and stored in the destination var (Triggers raised if set)
:rtype: string
:param string uVarName: The variable name for the action, from where the value is pulled
:param string uFindVar: The string to search for
:param string uDestVar: The name of the variable for the result (the Position) If not found, '-1' will be returned
:return: The position of the substring
"""
uValue = GetVar(uVarName=uVarName)
uValue = uVarName
if uValue == u'':
uValue = uVarName
uValue = ReplaceVars(uValue)
uFindVar = ReplaceVars(uFindVar)
iPos = uValue.find(uFindVar)
uResult = ToUnicode(iPos)
SetVar(uVarName=uDestVar, oVarValue=uResult)
Logger.debug(u'Var_Find: [%s] in [%s] returned [%s] (stored in [%s])' %
(uFindVar, uValue, uResult, uDestVar))
return uResult
