Beispiel #1
0
    def UpdateWidget(self) -> None:
        """ Updates the silder pos, based on the assigned Var """

        uValue: str
        fMax: float
        fMin: float

        super().UpdateWidget()

        if not self.uDestVar == u'':
            uValue = GetVar(uVarName=self.uDestVar)
            fNewValue = ToFloat(uValue)

            if GetVar(uVarName=self.uMax) != u'':
                fMax = ToFloat(GetVar(uVarName=self.uMax))
            else:
                fMax = self.fMax

            if GetVar(uVarName=self.uMin) != u'':
                fMin = ToFloat(GetVar(uVarName=self.uMin))
            else:
                fMin = self.fMin

            if fNewValue > fMax:
                fNewValue = fMax
            if fNewValue < fMin:
                fNewValue = fMin
            if self.oObject:
                self.oObject.SetValue(fNewValue)
            self.fValue = Round(fNewValue, self.iRoundPos)
        self.UpdateVars()
Beispiel #2
0
    def Create(self, oParent: Widget) -> bool:
        """ creates the Widget """
        try:
            self.fMin = ToFloat(ReplaceVars(self.uMin))
            self.fMax = ToFloat(ReplaceVars(self.uMax))
            self.AddArg('min', self.fMin)
            self.AddArg('max', self.fMax)
            self.AddArg('orientation', self.uDeviceOrientation)
            self.AddArg('value', self.fMin)
            self.AddArg('background_pic',
                        ToAtlas(oFileName=self.oFnPictureNormal))
            self.AddArg('button_pic', ToAtlas(oFileName=self.oFnPictureButton))
            if self.CreateBase(Parent=oParent, Class=cSliderEx):
                self.fDataRange = abs(self.fMax - self.fMin)
                self.oObject.bind(on_slider_moved=self.OnNotifyChange)
                # Capability to click on Knobs as well (needs to be implemented)
                if not self.uActionName == u'':
                    self.oObject.bind(on_release=self.On_Button_Up)
                    self.oObject.bind(on_press=self.On_Button_Down)

                self.oParent.add_widget(self.oObject)
                self.UpdateWidget()
                return True
            return False
        except Exception as e:
            LogError(uMsg=u'cWidgetSlider:Unexpected error Creating Object:',
                     oException=e)
            return False
Beispiel #3
0
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'
Beispiel #4
0
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''
Beispiel #5
0
 def __init__(self, **kwargs):
     self.register_event_type('on_release')
     super(SettingNumericSlider,
           self).__init__(**RemoveNoClassArgs(kwargs, SettingNumeric))
     self.fMin = ToFloat(kwargs["min"])
     self.fMax = ToFloat(kwargs["max"])
     self.iRoundPos = int(kwargs["roundpos"])
     self.slider = None
     self.textvalue = None
 def __init__(self, **kwargs):
     self.register_event_type('on_release')
     super().__init__(
         **RemoveNoClassArgs(dInArgs=kwargs, oObject=SettingNumeric))
     self.fMin: float = ToFloat(kwargs["min"])
     self.fMax: float = ToFloat(kwargs["max"])
     self.iRoundPos: int = int(kwargs["roundpos"])
     self.slider: Union[Slider, None] = None
     self.textvalue: Union[TextInput, None] = None
Beispiel #7
0
 def LogToSplashScreen2(self, *, uText: str, uPercentage: str = '') -> None:
     """ Logs a sub text message to the splash screen """
     self.oSplashLogger2.size = (Globals.iAppWidth * 0.95,
                                 Globals.iAppHeight / 3)
     self.oSplashLogger2.text_size = (Globals.iAppWidth * 0.95, None)
     self.oSplashLogger2.text = ReplaceVars(uText)
     if uPercentage != '':
         fPercentage: float
         if uPercentage.startswith('+'):
             fPercentage = self.oProgessBar.value + ToFloat(uPercentage[1:])
         else:
             fPercentage = ToFloat(uPercentage)
         self.oProgessBar.value = fPercentage
     return None
Beispiel #8
0
 def LogToSplashScreen2(self,uText,uPercentage=''):
     """ Logs a sub text message to the splash screen """
     self.oSplashLogger2.size                 =(Globals.iAppWidth*0.95,Globals.iAppHeight/3)
     self.oSplashLogger2.text_size            =(Globals.iAppWidth*0.95,None)
     self.oSplashLogger2.text                 = ReplaceVars(uText)
     if uPercentage!='':
         fPercentage=0
         if isinstance(uPercentage, string_types):
             if uPercentage.startswith('+'):
                 fPercentage=self.oProgessBar.value+ToFloat(uPercentage[1:])
             else:
                 fPercentage=ToFloat(uPercentage)
         else:
             fPercentage=ToFloat(uPercentage)
         self.oProgessBar.value=fPercentage
Beispiel #9
0
 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
Beispiel #10
0
    def Discover(self, **kwargs):

        uConfigName = self.uConfigName
        if "configname" in kwargs:
            uConfigName = kwargs['configname']

        oSetting = self.GetSettingObjectForConfigName(uConfigName=uConfigName)
        fTimeOut = oSetting.aScriptIniSettings.fTimeOut

        if "timeout" in kwargs:
            fTimeOut = ToFloat(kwargs['timeout'])

        self.fTimeOut = fTimeOut

        if self.oThread is None:
            self.StartThread()

        if not self.oThread.is_alive():
            self.StartThread()

        iCount = self.fTimeOut * 100
        while len(self.aiTachDevices
                  ) == 0 and iCount > 0 and self.oThread.is_alive():
            sleep(0.01)
            iCount = iCount - 1

        self.StopThread()
        if len(self.aiTachDevices) == 0:
            return {"Host": ""}
        else:
            uKey = self.aiTachDevices.keys()[0]
            return {"Host": self.aiTachDevices[uKey].uIP}
Beispiel #11
0
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'
Beispiel #12
0
    def InitWidgetFromXml(self, *, oXMLNode: Element,
                          oParentScreenPage: cScreenPage,
                          uAnchor: str) -> bool:
        """ Reads further Widget attributes from a xml node """

        bRet: bool = self.ParseXMLBaseNode(oXMLNode, oParentScreenPage,
                                           uAnchor)
        if bRet:
            self.uLineWidth = GetXMLTextAttributeVar(oXMLNode=oXMLNode,
                                                     uTag=u'linewidth',
                                                     bMandatory=False,
                                                     uDefault="1.0")
            if self.uBackGroundColor == "#00000000":
                self.aBackGroundColor = Globals.oTheScreen.oSkin.dSkinAttributes.get(
                    'color border')

            fPercentage: float = -1.0
            if not self.uLineWidth == u'':
                if self.uLineWidth.startswith('of:'):
                    self.iLineWidth = self._ParseDimPosValue(self.uLineWidth)
                elif self.uLineWidth[0] == u'%':
                    fPercentage = ToFloat(self.uLineWidth[1:])
                elif self.uLineWidth[0] == u'd':
                    self.iLineWidth = dp(ToInt(
                        self.uLineWidth[1:])) + self.iAnchorPosX
                else:
                    self.iLineWidth = ToInt(self.uLineWidth)
            if not fPercentage == -1.0:
                self.iLineWidth = ToInt(self.iAnchorPosX + (
                    (fPercentage / 100) * self.iAnchorWidth) -
                                        (self.iWidth * (fPercentage / 100)))
            self.iLineWidth = max(1, self.iLineWidth)

        return bRet
Beispiel #13
0
def Config_GetDefault_Float(*, oConfig: ConfigParser, uSection: str,
                            uOption: str, uDefaultValue: str) -> float:
    return ToFloat(
        Config_GetDefault_Str(oConfig=oConfig,
                              uSection=uSection,
                              uOption=uOption,
                              vDefaultValue=uDefaultValue))
Beispiel #14
0
def GetXMLFloatAttribute(*, oXMLNode: Element, uTag: str, bMandatory: bool,
                         fDefault: float) -> float:
    """ Returns an float from a xml attribute """
    return ToFloat(
        GetXMLTextAttribute(oXMLNode=oXMLNode,
                            uTag=uTag,
                            bMandatory=bMandatory,
                            vDefault=fDefault))
Beispiel #15
0
    def XY2RGB(self, **kwargs) -> None:
        """ Converts HUE xy to rgb and dumps it into vars """
        try:
            r: float
            g: float
            b: float
            fX: float
            fY: float

            fX = ToFloat(kwargs.get('x', 1.0))
            fY = ToFloat(kwargs.get('y', 1.0))
            uPrefix = kwargs.get('retvar', '')
            uLightKey = kwargs.get('index', '')
            uType = kwargs.get('type', 'Light')
            if uType == "Group":
                uType = "groups"
            else:
                uType = "lights"
            tGammut: Tuple = self._GetGamut(self.dStatus[uType][uLightKey].get(
                'modelid', ""))
            oConverter = self.oHueConverter.Converter(tGammut)
            r, g, b = oConverter.xy_to_rgb(fX, fY)

            dStatusLight: Dict = self.dStatus.get(uLightKey, {})
            if len(dStatusLight) > 0:
                uType = dStatusLight["lightstype"]

            self.oResultParser.SetVar2(str(r),
                                       "",
                                       uPrefix,
                                       u'Storing R-Value',
                                       uAddName=u"_r")
            self.oResultParser.SetVar2(str(g),
                                       "",
                                       uPrefix,
                                       u'Storing G-Value',
                                       uAddName=u"_g")
            self.oResultParser.SetVar2(str(b),
                                       "",
                                       uPrefix,
                                       u'Storing B-Value',
                                       uAddName=u"_b")
            return None
        except Exception as e:
            LogErrorSmall(uMsg="XY2RGB: Error parsing parameter", oException=e)
            return None
Beispiel #16
0
def GetXMLFloatAttributeVar(*, oXMLNode: Element, uTag: str, bMandatory: bool,
                            fDefault: float) -> float:
    """ Returns an float from a xml attribute (given as var)"""
    return ToFloat(
        ReplaceVars(
            GetXMLTextAttribute(oXMLNode=oXMLNode,
                                uTag=uTag,
                                bMandatory=bMandatory,
                                vDefault=ToUnicode(fDefault))))
Beispiel #17
0
    def ReadConfigFromIniFile(self, uConfigName):
        """ Reads the script config file """
        if self.aScriptIniSettings.bInitCompleted:
            return
        self.aScriptIniSettings.bInitCompleted = True

        if uConfigName != u'':
            self.uConfigName = uConfigName
            self.uContext = self.oScript.uScriptName + u'/' + self.uConfigName
        self.uSection = self.uConfigName

        try:
            self.oScript.oScriptConfig.LoadConfig()
            SetVar(uVarName=u'ScriptConfigSection', oVarValue=uConfigName)
            dIniDef = self.oScript.oScriptConfig.CreateSettingJsonCombined(
                self)

            for uKey2 in dIniDef:
                oLine = dIniDef[uKey2]
                uType = oLine.get("type")
                uKey = oLine.get("key")
                uDefault = oLine.get("default")

                if uKey is None or uDefault is None:
                    continue

                # we replace JSON defaults by script-settings defaults, if exists
                if self.aScriptIniSettings.queryget(uKey) is not None:
                    uDefault = self.aScriptIniSettings.queryget(uKey)

                uResult = Config_GetDefault_Str(
                    self.oScript.oScriptConfig.oConfigParser, self.uSection,
                    uKey, uDefault)

                if uType == "scrolloptions" or uType == "string":
                    self.aScriptIniSettings[uKey] = ReplaceVars(uResult)
                elif uType == "numeric" or uType == "numericslider":
                    self.aScriptIniSettings[uKey] = ToInt(uResult)
                elif uType == "numericfloat":
                    self.aScriptIniSettings[uKey] = ToFloat(uResult)
                elif uType == "bool":
                    self.aScriptIniSettings[uKey] = ToBool(uResult)
                elif uType == "title" or uType == "buttons" or uType == "path" or uType == "varstring":
                    pass
                else:
                    self.ShowError(
                        u'Cannot read config name (base), wrong attribute:' +
                        self.oScript.oScriptConfig.oFnConfig.string +
                        u' Section:' + self.uSection + " " + oLine["type"])

            self.oScript.oScriptConfig.oConfigParser.write()
        except Exception as e:
            self.ShowError(uMsg=u'Cannot read config name (base):' +
                           self.oScript.oScriptConfig.oFnConfig.string +
                           u' Section:' + self.uSection,
                           oException=e)
            return
Beispiel #18
0
def Var_Increase(uVarName, uStep='1', uMax=''):
    """
    Increase a given variable value.
    The changed variable value will be return and stored in the user vars (Triggers raised if set)

    :rtype: string
    :param string uVarName: The variable name for the action, from where the value is pulled
    :param string uStep: The value to added to the original value, can be a variable itself
    :param string uMax: The maximum value, which can't be exceeded, can be a variable itself, If empty, no limit is used
    :return: The changed variable value
    """

    uValue = u''
    try:
        uValue = GetVar(uVarName=uVarName)
        uValueOrg = uValue

        if uValue == u'':
            uValue = '0'
        uStepToUse = GetVar(uVarName=uStep)
        if uStepToUse == u'':
            uStepToUse = uStep
        uStepToUse = ReplaceVars(uStepToUse)
        uMaxToUse = GetVar(uVarName=uMax)
        if uMaxToUse == u'':
            uMaxToUse = uMax

        fValue = ToFloat(uValue)
        fValue += ToFloat(uStepToUse)
        if not uMaxToUse == u'':
            fMaxToUse = ToFloat(uMaxToUse)
            if fValue > fMaxToUse:
                fValue = fMaxToUse
        uValue = ToUnicode(fValue)
        uValue = Var_NormalizeInt(uValue)
        SetVar(uVarName=uVarName, oVarValue=uValue)
        Logger.debug(
            u'Var_Increase: [%s] plus [%s] returned [%s]  (stored in [%s])' %
            (uValueOrg, uStepToUse, uValue, uVarName))
    except Exception as e:
        LogError(u'Var_Increase: Invalid Argument', e)
        return u'Error'

    return uValue
Beispiel #19
0
    def UpdateWidget(self):

        if not self.uDestVar == u'':
            if not self.fDataRange == 0:
                uValue = GetVar(uVarName=self.uDestVar)
                fNewValue = ToFloat(uValue)
                iNewProz = (fNewValue - self.fMin) / self.fDataRange
                iNewDegree = self.iLeftBoundaryAngle + self.iRange * iNewProz
                self.oObject.SetValue(iNewDegree)
                self.fValue = Round(fNewValue, self.iRoundPos)
            self.UpdateVars()
Beispiel #20
0
def Var_Decrease(uVarName: str, uStep: str, uMin: str) -> str:
    """
    Decrease 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 uStep: The value to added to the original value, can be a variable itself
    :param str uMin: The minimum value, which can't be deceeded, can be a variable itself, If empty, no limit is used
    :return: The changed variable value
    """

    try:
        uValue: str = GetVar(uVarName=uVarName)
        uValueOrg: str = uValue
        if uValue == u'':
            uValue = '0'

        uStepToUse: str = GetVar(uVarName=uStep)
        if uStepToUse == u'':
            uStepToUse = uStep
        uMinToUse: str = GetVar(uVarName=uMin)
        uMinToUse = ReplaceVars(uMinToUse)
        if uMinToUse == u'':
            uMinToUse = uMin

        fValue: float = ToFloat(uValue)
        fValue -= ToFloat(uStepToUse)
        if not uMinToUse == u'':
            fMinToUse = ToFloat(uMinToUse)
            if fValue < fMinToUse:
                fValue = fMinToUse
        uValue = ToUnicode(fValue)
        uValue = Var_NormalizeInt(uValue)
        SetVar(uVarName=uVarName, oVarValue=uValue)
        Logger.debug(
            u'Var_Decrease: [%s] minus [%s] returned [%s]  (stored in [%s])' %
            (uValueOrg, uStepToUse, uValue, uVarName))
        return uValue
    except Exception as e:
        LogError(uMsg=u'Var_Decrease: Invalid Argument', oException=e)
        return u'Error'
Beispiel #21
0
    def UpdateWidget(self):

        if not self.uDestVar==u'':

            h=GetVar(uVarName = self.uDestVar+u'_h')
            s=GetVar(uVarName = self.uDestVar+u'_s')
            v=GetVar(uVarName = self.uDestVar+u'_v')

            r=''

            if h!='':
                h=ToFloat(h)/255
                s=ToFloat(s)/255
                v=ToFloat(v)/255
                r,g,b=hsv_to_rgb(h,s,v)
            else:
                r=GetVar(uVarName = self.uDestVar+u'_r')
                g=GetVar(uVarName = self.uDestVar+u'_g')
                b=GetVar(uVarName = self.uDestVar+u'_b')

            if r=='':
                oColor=GetColorFromHex(GetVar(uVarName = self.uDestVar))
                if len(oColor)==0:
                    oColor= Color(1, 1, 1, 1)
                else:
                    r,g,b,a=GetColorFromHex(GetVar(uVarName = self.uDestVar))

            if r!='':
                r = ToFloat(r) / 255
                g = ToFloat(g) / 255
                b = ToFloat(b) / 255
                self.oObjectColorPicker.color=(r,g,b,1)
Beispiel #22
0
    def PlaySound(self,
                  *,
                  uSoundName: str,
                  vSoundVolume: Union[float, str] = -1.0) -> bool:
        """ plays a given sound with a given volume """
        iSoundVolume: int
        fVolume: float
        vVolume: Union[str, float]
        dSound: Optional[Dict[str, Union[cFileName, int]]]
        oFnSound: cFileName

        if self.bMute:
            return True

        try:
            dSound = self.aSounds.get(uSoundName)
            vVolume = vSoundVolume
            if dSound is not None:
                oFnSound = dSound["oFnSound"]
                iSoundVolume = dSound["iSoundVolume"]
            else:
                oFnSound = cFileName('').ImportFullPath(uFnFullName=uSoundName)
                iSoundVolume = 100

            if oFnSound and not oFnSound.IsEmpty():
                oSound = self.dSoundObjects.get(oFnSound.string)
                # temporary disabled
                if oSound is None or True:
                    oSound = SoundLoader.load(oFnSound.string)
                    self.dSoundObjects[oFnSound.string] = oSound
                if oSound:
                    if oSound.state != 'stop':
                        oSound.stop()

                    if isinstance(vSoundVolume, str):
                        if vSoundVolume != u'':
                            vVolume = ToFloat(vSoundVolume)

                    if not vVolume == -1.0 and not vVolume == u'':
                        fVolume = cast(float, vVolume) * (iSoundVolume / 100.0)
                    else:
                        fVolume = iSoundVolume * 1.0

                    fVolume = fVolume / 100.0
                    oSound.volume = fVolume

                    if fVolume > 0:
                        oSound.play()
            return True
        except Exception as e:
            LogError(uMsg=u'Playing sound failed:' + uSoundName, oException=e)
            return False
Beispiel #23
0
def Var_Divide(uVarName, uDivisor):
    """
    Divides a given variable value.
    The changed variable value will be return and stored in the user vars (Triggers raised if set)

    :rtype: string
    :param string uVarName: The variable name for the action, from where the value is pulled
    :param string uDivisor: The value to divide the original value with, can be a variable itself
    :return: The changed variable value
    """

    uValue = u''
    try:
        uValue = GetVar(uVarName=uVarName)
        uValueOrg = uValue
        if uValue == u'':
            return u''

        uDivisorToUse = GetVar(uVarName=uDivisor)
        if uDivisorToUse == '':
            uDivisorToUse = uDivisor
        uDivisorToUse = ReplaceVars(uDivisorToUse)
        fDivisor = ToFloat(uDivisorToUse)

        if fDivisor == 0:
            return uValue

        fValue = ToFloat(uValue)
        fValue = fValue / fDivisor
        uValue = ToUnicode(fValue)
        uValue = Var_NormalizeInt(uValue)
        SetVar(uVarName=uVarName, oVarValue=uValue)
        Logger.debug(
            u'Var_Divide: [%s] / [%s] returned [%s]  (stored in [%s])' %
            (uValueOrg, uDivisorToUse, uValue, uVarName))
    except Exception as e:
        LogError(u'Var_Divide: Invalid Argument', e)
        return u'Error'
    return uValue
Beispiel #24
0
    def Discover(self, **kwargs):

        uConfigName = kwargs.get('configname', self.uConfigName)
        oSetting = self.GetSettingObjectForConfigName(uConfigName=uConfigName)
        fTimeOut = ToFloat(
            kwargs.get('timeout', oSetting.aScriptIniSettings.fTimeOut))
        bOnlyOnce = ToBool(kwargs.get('onlyonce', "1"))

        del self.aResults[:]
        del self.aThreads[:]

        uIPSubNet = Globals.uIPGateWayAssumedV4
        uIPSubNet = uIPSubNet[:uIPSubNet.rfind(".")] + "."

        for i in range(154, 155):
            uIP = uIPSubNet + str(i)
            oThread = cThread_CheckIP(uIP=uIP,
                                      bOnlyOnce=bOnlyOnce,
                                      fTimeOut=fTimeOut,
                                      oCaller=self)
            self.aThreads.append(oThread)
            oThread.start()

        for oT in self.aThreads:
            oT.join()

        if len(self.aResults):
            uHost = self.aResults[0]["ip"]
            uPort = self.aResults[0]["port"]
            uModel = self.aResults[0]["model"]
            uHostName = self.aResults[0]["hostname"]
            uIPVersion = self.aResults[0]["ipversion"]
            return {
                'Host': uHost,
                'Port': uPort,
                'Model': uModel,
                'Hostname': uHostName,
                "IPVersion": uIPVersion,
                'Exception': None
            }

        LogErrorSmall(
            "Enigma-Discover: Could not find a Enigma Receiver on the network")
        return {
            'Host': '',
            'Port': '',
            'Model': '',
            'Hostname': '',
            "IPVersion": '',
            'Exception': None
        }
Beispiel #25
0
    def Discover(self, **kwargs):

        self.dReq.uSerial = kwargs.get('serialnumber', "")
        uConfigName: str = kwargs.get('configname', self.uConfigName)
        oSetting: cBaseScriptSettings = self.GetSettingObjectForConfigName(
            uConfigName=uConfigName)
        fTimeOut: float = ToFloat(
            kwargs.get('timeout', oSetting.aIniSettings.fTimeOut))
        bOnlyOnce: bool = ToBool(kwargs.get('onlyonce', "1"))
        self.bDoNotWait = ToBool(kwargs.get('donotwait', "0"))

        del self.aResults[:]
        del self.aThreads[:]

        self.ShowDebug(uMsg=u'Try to discover ELV MAX device:  %s ' %
                       self.dReq.uSerial)

        try:
            oThread = cThread_Discover_ELVMAX(bOnlyOnce=bOnlyOnce,
                                              dReq=self.dReq,
                                              uIPVersion="IPv4Only",
                                              fTimeOut=fTimeOut,
                                              oCaller=self)
            self.aThreads.append(oThread)
            self.aThreads[-1].start()
            if not self.bDoNotWait:
                for oT in self.aThreads:
                    oT.join()
                self.SendEndNotification()
                if len(self.aResults) > 0:
                    return TypedQueryDict([
                        ("Host", self.aResults[0].uFoundIP),
                        ("Hostname", self.aResults[0].uFoundHostName),
                        ("Serial", self.aResults[0].uFoundSerial),
                        ("Name", self.aResults[0].uFoundName)
                    ])
                else:
                    self.ShowWarning(uMsg=u'No ELV MAX Cube found %s' %
                                     self.dReq.uSerial)
                    TypedQueryDict([("Host", ""), ("Hostname", ""),
                                    ("Serial", ""), ("Name", "")])
            else:
                self.ClockCheck = Clock.schedule_interval(
                    self.CheckFinished, 0.1)

        except Exception as e:
            self.ShowError(uMsg="Error on Discover", oException=e)

        return TypedQueryDict([("Host", ""), ("Hostname", ""), ("Serial", ""),
                               ("Name", "")])
Beispiel #26
0
    def RGB2XY(self, **kwargs) -> None:
        """ Converts rgb values to hue xy and dumps it into vars """
        try:
            fR: float = ToFloat(ReplaceVars(kwargs.get('r', 1.0)))
            fG: float = ToFloat(ReplaceVars(kwargs.get('g', 1.0)))
            fB: float = ToFloat(ReplaceVars(kwargs.get('b', 1.0)))
            uPrefix: str = ReplaceVars(kwargs.get('retvar', ''))
            uLightKey: str = ReplaceVars(kwargs.get('index', ''))
            uType: str = ReplaceVars(kwargs.get('type', 'Light'))
            if uType == "Group":
                uType = "groups"
            else:
                uType = "lights"

            tGammut: Tuple = self._GetGamut(self.dStatus[uType][uLightKey].get(
                'modelid', ""))
            oConverter = self.oHueConverter.Converter(tGammut)
            x, y = oConverter.rgb_to_xy(fR, fG, fB)
            if uPrefix == '':
                oAction = kwargs['oAction']
                if oAction is not None:
                    uPrefix = oAction.uRetVar

            self.oResultParser.SetVar2(str(x),
                                       "",
                                       uPrefix,
                                       u'Storing X-Value',
                                       uAddName=u"_x")
            self.oResultParser.SetVar2(str(y),
                                       "",
                                       uPrefix,
                                       u'Storing Y-Value',
                                       uAddName=u"_y")
            return None
        except Exception as e:
            LogErrorSmall(uMsg="RGB2XY: Error parsing parameter", oException=e)
            return None
Beispiel #27
0
    def UpdateWidget(self):
        """ Updates the silder pos, based on the assigned Var """
        if not self.uDestVar == u'':
            uValue = GetVar(uVarName=self.uDestVar)
            fNewValue = ToFloat(uValue)

            if isinstance(self.fMax, float):
                fMax = self.fMax
            else:
                fMax = ToFloat(GetVar(uVarName=self.fMax))

            if isinstance(self.fMin, float):
                fMin = self.fMin
            else:
                fMin = ToFloat(GetVar(uVarName=self.fMin))

            if fNewValue > fMax:
                fNewValue = fMax
            if fNewValue < fMin:
                fNewValue = fMin
            if self.oObject:
                self.oObject.SetValue(fNewValue)
            self.fValue = Round(fNewValue, self.iRoundPos)
        self.UpdateVars()
Beispiel #28
0
    def Discover(self,**kwargs):

        self.dReq.clear()
        uConfigName:str              = kwargs.get('configname',self.uConfigName)
        oSetting:cBaseScriptSettings = self.GetSettingObjectForConfigName(uConfigName=uConfigName)
        self.dReq.bReturnPort        = ToBool(kwargs.get('returnport',"0"))
        fTimeOut:float               = ToFloat(kwargs.get('timeout',oSetting.aIniSettings.fTimeOut))
        uIPVersion:str               = kwargs.get('ipversion',"IPv4Only")
        bOnlyOnce:bool               = ToBool(kwargs.get('onlyonce',"1"))
        self.bDoNotWait              = ToBool(kwargs.get('donotwait',"0"))

        Logger.debug (u'Try to discover device by Kira Discovery (%s)' % uIPVersion)

        del self.aResults[:]
        del self.aThreads[:]

        try:
            if uIPVersion == "IPv4Only" or uIPVersion == "All" or (uIPVersion == "Auto" and Globals.uIPAddressV6 == ""):
                oThread = cThread_Discover_Kira(bOnlyOnce=bOnlyOnce,dReq=self.dReq,uIPVersion="IPv4Only", fTimeOut=fTimeOut, oCaller=self)
                self.aThreads.append(oThread)
                self.aThreads[-1].start()
            if uIPVersion == "IPv6Only" or uIPVersion == "All" or (uIPVersion == "Auto" and Globals.uIPAddressV6 != ""):
                oThread = cThread_Discover_Kira(bOnlyOnce=bOnlyOnce, dReq=self.dReq, uIPVersion="IPv6Only", fTimeOut=fTimeOut, oCaller=self)
                self.aThreads.append(oThread)
                self.aThreads[-1].start()

            if not self.bDoNotWait:
                for oT in self.aThreads:
                    oT.join()
                self.SendEndNotification()

                if len(self.aResults)>0:
                    return {"Host":self.aResults[0].uFoundIP,
                            "Hostname": self.aResults[0].uFoundHostName,
                            'Exception': None}
                else:
                    Logger.warning(u'Kira Discover: No device found' )
            else:
                self.ClockCheck=Clock.schedule_interval(self.CheckFinished,0.1)
            return {"Host": "",
                    "Hostname": "",
                    'Exception': None}

        except Exception as e:
            LogError(uMsg=u'Error on discover uPnP',oException=e)
            return {"Host": "",
                    "Hostname": "",
                    'Exception': e}
Beispiel #29
0
    def Discover(self, **kwargs) -> Dict[str, str]:

        uConfigName: str = kwargs.get('configname', self.uConfigName)
        oSetting: cBaseScriptSettings = self.GetSettingObjectForConfigName(
            uConfigName=uConfigName)
        self.fTimeOut: float = ToFloat(
            kwargs.get('timeout', oSetting.aIniSettings.fTimeOut))
        self.dReq.uModels = kwargs.get('models', "")
        self.uIPVersion: str = kwargs.get('ipversion', "IPv4Only")
        self.bDoNotWait = ToBool(kwargs.get('donotwait', "0"))

        self.ShowDebug(uMsg=u'Try to discover iTach device')

        del self.aResults[:]

        try:
            oThread: cThread_Discover_iTach
            if len(self.aThreads) == 0:
                self.StartThread()

            if not self.aThreads[0].is_alive():
                self.StartThread()

            for oT in self.aThreads:
                oT.join()
            self.SendEndNotification()

            if len(self.aResults) > 0:
                return {"Host": self.aResults[0].uFoundIP}

            if len(self.aResults) > 0:
                #for dDevice in self.aResults:
                #    Globals.oNotifications.SendNotification(uNotification="DISCOVER_SCRIPTFOUND",**{"script":self,"scriptname":self.uObjectName,"line":[dDevice.uIP , dDevice.uUUID , dDevice.uModel ,dDevice.uRevision ],"device":dRet})
                return {
                    'Model': self.aResults[0].uModel,
                    'Host': self.aResults[0].uIP,
                    'Port': '4998',
                    'Exception': None
                }
            else:
                self.ShowWarning(uMsg='No iTach device found')
        except Exception as e:
            self.ShowError(uMsg=u'No iTach device found, possible timeout',
                           oException=e)

        return {"Host": ""}
Beispiel #30
0
    def UpdateWidget(self) -> None:

        super().UpdateWidget()

        fNewValue: float
        fNewProz: float
        fNewDegree: float
        uValue: str

        if not self.uDestVar == u'':
            if not self.fDataRange == 0:
                uValue = GetVar(uVarName=self.uDestVar)
                fNewValue = ToFloat(uValue)
                fNewProz = (fNewValue - self.fMin) / self.fDataRange
                fNewDegree = self.iLeftBoundaryAngle + self.iRange * fNewProz
                self.oObject.SetValue(fNewDegree)
                self.fValue = Round(fNewValue, self.iRoundPos)
            self.UpdateVars()