def parseInt(self, text, base): """ Extracts an integer from a string. Parses a string to find the first set of characters, in a specified base, that can be converted to an integer, and returns that integer, or NaN if it does not encounter characters that it can convert to a number. :param text: The string from which to extract an integer. :param base: The base of the string to parse (from base 2 to base 36). If not supplied, base is determined by the format of string. :type text: str :type base: float """ PymiereBaseObject._check_type( text, str, 'arg "text" of function "StartVars.parseInt"') PymiereBaseObject._check_type( base, float, 'arg "base" of function "StartVars.parseInt"') return _eval_on_global_object("parseInt({}, {})".format( _format_object_to_es(text), _format_object_to_es(base)))
def setDefaultXMLNamespace(self, ns): """ Defines the default XML namespace. This is a replacement function for the standard JavaScript statement set default xml namespace. :param namespace: The namespace to use. Omit this parameter to return to the empty namespace. This is either a Namespace object or a string. :type ns: Namespace """ return _eval_on_global_object("setDefaultXMLNamespace({})".format(_format_object_to_es(ns)))
def decodeURIComponent(self, uri): """ Decodes a string created with encodeURIComponent(). :param uri: The text to decode. :type uri: str """ PymiereBaseObject._check_type(uri, str, 'arg "uri" of function "StartVars.decodeURIComponent"') return _eval_on_global_object("decodeURIComponent({})".format(_format_object_to_es(uri)))
def isXMLName(self, name): """ Returns true if the supplied string is a valid XML name. :param name: The XML name to test. :type name: str """ PymiereBaseObject._check_type(name, str, 'arg "name" of function "StartVars.isXMLName"') return _eval_on_global_object("isXMLName({})".format(_format_object_to_es(name)))
def unescape(self, uri): """ Translates URL-encoded string into a regular string, and returns that string. Use the escape() global function to URL-encode strings. :param stringExpression: The URL-encoded string to convert. :type uri: str """ PymiereBaseObject._check_type(uri, str, 'arg "uri" of function "StartVars.unescape"') return _eval_on_global_object("unescape({})".format(_format_object_to_es(uri)))
def parseFloat(self, txt): """ Extracts a floating-point number from a string. Parses a string to find the first set of characters that can be converted to a floating point number, and returns that number, or NaN if it does not encounter characters that it can converted to a number.The function supports exponential notation. :param text: The string from which to extract a floating point number. :type txt: str """ PymiereBaseObject._check_type(txt, str, 'arg "txt" of function "StartVars.parseFloat"') return _eval_on_global_object("parseFloat({})".format(_format_object_to_es(txt)))
def isNaN(self, what): """ Evaluates an expression and reports whether the result is "Not-a-Number" (NaN). Returns true if the result of evaluation is not a number (NaN), false if the value is a number. :param expression: Any valid JavaScript expression. :type what: float """ PymiereBaseObject._check_type(what, float, 'arg "what" of function "StartVars.isNaN"') return _eval_on_global_object("isNaN({})".format(_format_object_to_es(what)))
def isFinite(self, what): """ Evaluates an expression and reports whether the result is a finite number. Returns true if the expression is a finite number, false otherwise. False if the value is infinity or negative infinity. :param expression: Any valid JavaScript expression. :type what: float """ PymiereBaseObject._check_type(what, float, 'arg "what" of function "StartVars.isFinite"') return _eval_on_global_object("isFinite({})".format(_format_object_to_es(what)))
def uneval(self, what): """ Creates a source code representation of the supplied argument, and returns it as a string. :param what: The object to uneval. :type what: any """ PymiereBaseObject._check_type(what, any, 'arg "what" of function "StartVars.uneval"') return _eval_on_global_object("uneval({})".format(_format_object_to_es(what)))
def eval(self, source): """ Evaluates its argument as a JavaScript script, and returns the result of evaluation. You can pass the result of an object's toSource() method to reconstruct that object. :param stringExpression: The string to evaluate. :type source: str """ PymiereBaseObject._check_type(source, str, 'arg "source" of function "StartVars.eval"') return _eval_on_global_object("eval({})".format(_format_object_to_es(source)))
def escape(self, text): """ Creates a URL-encoded string from aString. In the new string, characters of aString that require URL encoding are replaced with the format %xx, where xx is the hexadecimal value of the character code in the Unicode character set.This format is used to transmit information appended to a URL during, for example, execution of the GET method.Use the unescape() global function to translate the string back into its original format. Returns a string which is aString URL-encoded. :param aString: The string to be encoded. :type text: str """ PymiereBaseObject._check_type(text, str, 'arg "text" of function "StartVars.escape"') return _eval_on_global_object("escape({})".format(_format_object_to_es(text)))
def encodeURIComponent(self, text): """ Encodes a string after RFC2396. Create an UTF-8 ASCII encoded version of this string. The string is converted into UTF-8. Every non-alphanumeric character is encoded as a percent escape character of the form %xx, where xx is the hex value of the character. After the conversion to UTF-8 encoding and escaping, it is guaranteed that the string does not contain characters codes greater than 127. The list of characters not to be encoded is -_.!~'(). The method returns false on errors. :param text: The text to encode. :type text: str """ PymiereBaseObject._check_type(text, str, 'arg "text" of function "StartVars.encodeURIComponent"') return _eval_on_global_object("encodeURIComponent({})".format(_format_object_to_es(text)))
def localize(self, what): """ Localizes a ZString-encoded string and merges additional arguments into the string. :param what: The string to localize. A ZString-encoded string that can contain placeholder for additional arguments in the form %1 to %n. :param arguments: Optional argument(s) to be merged into the string. There may be more than one argument. :type what: any """ PymiereBaseObject._check_type(what, any, 'arg "what" of function "StartVars.localize"') return _eval_on_global_object("localize({})".format(_format_object_to_es(what)))
def prompt(self, prompt): """ Displays a dialog allowing the user to enter text Returns null if the user cancelled the dialog, the text otherwise :param prompt: The text to display :param default_: The default text to preset the edit field with :param title: The title of the dialog; :type prompt: str """ PymiereBaseObject._check_type(prompt, str, 'arg "prompt" of function "StartVars.prompt"') return _eval_on_global_object("prompt({})".format(_format_object_to_es(prompt)))
def confirm(self, prompt): """ Displays an alert box with Yes and No buttons; returns true for Yes :param message: The text to display :param noAsDefault: Set to true to set the No button as the default button :param title: The title of the alert; ignored on the Macintosh :type prompt: str """ PymiereBaseObject._check_type(prompt, str, 'arg "prompt" of function "StartVars.confirm"') return _eval_on_global_object("confirm({})".format(_format_object_to_es(prompt)))
def alert(self, prompt): """ Displays an alert box :param message: The text to display :param title: The title of the alert; ignored on the Macintosh :param errorIcon: Display an Error icon; ignored on the Macintosh :type prompt: str """ PymiereBaseObject._check_type(prompt, str, 'arg "prompt" of function "StartVars.alert"') _eval_on_global_object("alert({})".format(_format_object_to_es(prompt)))
def NaN(self, NaN): PymiereBaseObject._check_type(NaN, float, 'StartVars.NaN') _eval_on_global_object("NaN = {}".format(_format_object_to_es(NaN))) self.__NaN = NaN
def Infinity(self, Infinity): PymiereBaseObject._check_type(Infinity, float, 'StartVars.Infinity') _eval_on_global_object("Infinity = {}".format( _format_object_to_es(Infinity))) self.__Infinity = Infinity
def JSON(self, JSON): _eval_on_global_object("JSON = {}".format(_format_object_to_es(JSON))) self.__JSON = JSON
def undefined(self, undefined): PymiereBaseObject._check_type(undefined, None, 'StartVars.undefined') _eval_on_global_object("undefined = {}".format( _format_object_to_es(undefined))) self.__undefined = undefined
def f(self, f): PymiereBaseObject._check_type(f, File, 'StartVars.f') _eval_on_global_object("f = {}".format(_format_object_to_es(f))) self.__f = f
def CCXHostBridge(self, CCXHostBridge): _eval_on_global_object("CCXHostBridge = {}".format( _format_object_to_es(CCXHostBridge))) self.__CCXHostBridge = CCXHostBridge
def PHXSBridge(self, PHXSBridge): _eval_on_global_object("PHXSBridge = {}".format( _format_object_to_es(PHXSBridge))) self.__PHXSBridge = PHXSBridge
def AEFTBridge(self, AEFTBridge): _eval_on_global_object("AEFTBridge = {}".format( _format_object_to_es(AEFTBridge))) self.__AEFTBridge = AEFTBridge
def premierepro13(self, premierepro13): _eval_on_global_object("premierepro13 = {}".format( _format_object_to_es(premierepro13))) self.__premierepro13 = premierepro13