mozdev.org

Properties

• Connected: Boolean
  
  When true the object is connected to an instance of TJSEngine, permitting interaction with script code.
• Destroying: Boolean
  
  Developers should not need to access this property. It is used when an instance of TJSEngine is shut down.
• Engine: TJSEngine
  
  Use this property to access the engine to which the TJSObject is connected.
• JScriptVal: jsval
  
  Only advanced developers should use this property. It can be used in SpiderMonkey callback functions, or API calls, for instance.
• JSName: string
  
  This is the name associated with the variable in JavaScript.
• JSObject: PJSObject
  
  Only advanced users should use this property. A developer can use this value when working with the SpiderMonkey API.
• Parent: TJSObject
  
  The parent is the scope from which the current TJSObject is accessible. If no parent was assigned when the TJSObject was created it will default to TJSEngine.Global.

Methods

• constructor Create(AValue: PJSObject; AEngine: TJSEngine; const AName: string);
  
  Creates a new TJSObject at the global scope named AName.
• constructor Create(AValue: PJSObject; AEngine: TJSEngine; const AName: string; AParent: TJSObject);
  
  Creates a new TJSObject at the specified scope named AName.
• function AddMethod(const name: String; proc: JSNative; paramcount: Integer): TJSFunction;
  
  Intended for more advanced users. Adds the function called name to the current TJSObject's scope. proc, of type JSNativeA non-object function prototype whose definition is as follows:
  function(cx: PJSContext; obj: PJSObject; argc: uintN; argv: pjsval; rval: pjsval): JSBool; cdecl; is the procedure that SpiderMonkey will call for this function, and paramcount is the number of parameters that the function expects to receive. The resulting TJSFunction is merely a wrapper for the method. Keep in mind the TJSFunction instance cannot be retrieved once it goes out of scope, although the JavaScript function remains declared.
• function AddMethods(var methods: TJSFunctionSpecArray): Boolean;
  
  Intended for more advanced users. Adds the list of functions specified in the methods array. A TJSFunctionSpecArray is an array of JSFunctionSpecA record with a fairly simple structure:
    JSFunctionSpec = record
    name: PChar;
    call: JSNative; // See AddMethod
    nargs: uint8;   // Byte
    flags: uint8;   // Byte
    extra: uint16;  // Word
  end;
  
  Where nargs is the number of arguments the function expects, flags is any of the JSFUN_* flag values, and extra can be ignored. records.
• function AddNativeObject(Obj: TObject; const InstanceName: String): TJSObject;
  
  Processes a native Delphi / Kylix object so that its published methods and properties are accessible to script by the name in InstanceName. The returned TJSObject is merely a wrapper. Note: The object's class must be compiled with {$M+} and {$M-} around it.
• function AddObject(var cls: JSClass; const AName: string): TJSObject;
  
  Intended for more advanced users. A developer may declare a custom JavaScript object, with Delphi or Kylix hooks, as seen in the jssamples.pas file. The new JavaScript object is given the name in AName.
• function AddProperties(var props: TJSPropertySpecArray): Boolean;
  
  Intended for more advanced users. Adds the list of properties specified in the props array. A TJSPropertySpecArray is an array of JSPropertySpecA record with a fairly simple structure:
    JSPropertySpec = record
    name: PChar;
    tinyid: int8;
    flags: uint8;   // Byte
    getter: JSPropertyOp;
    setter: JSPropertyOp;
  end;
  
  Where tinyid should not be used, and flags is any of the JSPROP_* flag values. getter and setter are non-object procedure prototypes which can be declared (if the developer wishes to customize the getting & setting of the property) or simply nil. records.
• function Call(const Func: string; params: array of TJSBase; var str: string): Boolean;
  function Call(const Func: string; params: array of TJSBase; var int: Integer): Boolean;
  function Call(const Func: string; params: array of TJSBase; var dbl: Double): Boolean;
  function Call(const Func: string; params: array of TJSBase; var res: TJSObject): Boolean;
  function Call(const Func: string; params: array of TJSBase; var bool: Boolean): Boolean;
  
  These methods call the JavaScript function Func with parameters params, and attempts to return a value into the third parameter. If the method returns false the call, or the return value conversion, failed. For example:
  
  eng := TJSEngine.Create(40000);
try
  global := eng.Global;
  global.Evaluate('function addSix(p_int) { return p_int +6; }');
  myint := global.Declare(16); // declared anonymous since it is only a parameter
  if (global.Call('addSix', [myint], integerResult)) then
    ShowMessage('addSix returned ' +IntToStr(integerResult));
finally
  eng.Free;
end;

• function ClassType(const Name: String): JSClassType;
  
  Tells you the type of a property, returns one of ctDate, ctArray, ctString, ctNumber, ctBoolean, ctUnknownClass, ctUnknownType.
• procedure Connect(AEngine: TJSEngine; AName: string; AParent: TJSObject);
  procedure Connect(AEngine: TJSEngine; AName: string);
  
  Connects the TJSObject to the engine. The first declaration will assign the JavaScript object to the specified scope, while the second will default the scope to global.
• function Declare(val: Double; const name: string = ''): TJSDouble;
  function Declare(val: Integer; const name: string = ''): TJSInteger;
  function Declare(const val: string; const name: string = ''): TJSString;
  function Declare(var val: TJSBaseArray; const name: string = ''): TJSArray;
  function Declare(val: Boolean; const name: string = ''): TJSBoolean;
  
  These methods create bridge variables A bridge variable is one that can be modified by both Delphi / Kylix code and script code. Any change made in one will be reflected in the other. of the specified type. Declaring a variable without a name creates an anonymous variable Anonymous variables do not have names, and are only usable as parameters when calling a JavaScript function. Assign the variable a name to use it within script code. (See the Call method of TJSObject.). For all other purposes provide a name for the variable as well.
• function DeclareObject(const name: string): TJSObject;
  
  This method creates a new JavaScript object with the name name underneath the current object's scope, and returns a TJSObject wrapper for that object.
• function Enumerate: TStringArray;
  
  This method returns a list of all of the properties and methods that are enumerable for the current object. See the jssamples.pas file for an example of how to use this method.
• function Evaluate(const code: string): Boolean;
  
  This method runs the JavaScript in code within the scope of the current object. This method returns true if the execution completed successfully.
• function GetFunction(const name: String): TJSFunction;
  
  This method allows you to recover TJSFunction instances when they go out of scope. Note that the JavaScript function will continue to execute even after a TJSFunction has gone out of scope.
• function GetNativeProperty(Obj: TObject; AName: PChar): jsval;
  
  Developers should not need to use this method at all. It is used by callbacks in jsintf_bridge.pas.
• function GetProperty(const name: string; var dbl: Double): Boolean;
  function GetProperty(const name: string; var int: Integer): Boolean;
  function GetProperty(const name: string; var ret: TJSObject): Boolean;
  function GetProperty(const name: string; var str: string): Boolean;
  function GetProperty(const name: string; var bool: Boolean): Boolean;
  
  These methods permit developers to retrieve any property of the current object, provided the type is correct. If the property does not exist, or the property type conversion fails, the method will return false.
• function HasProperty(const name: String): Boolean;
  
  This method returns true if the current object has the property called name.
• function IsFunction(const name: String): Boolean;
  
  This method allows developers to determine if the property called name is a function.
• function IsInteger(const name: String): Boolean;
  
  This method allows developers to determine whether the property called name is an integer or a floating point value. (Usually used in conjunction with TJSObject.TypeOf.)
• procedure RemoveObject(Obj: TJSBase);
  
  This method deletes the specified property from the current object, and frees the instance of Obj.
• function SetNativeProperty(Obj: TObject; AName, AValue: PChar): JSBool;
  
  Developers should not need to use this method at all. It is used by callbacks in jsintf_bridge.pas.
• function SetProperty(const name: string; val: TJSBase): Boolean;
  
  This method sets the property specified by name to the value specified in val. Returns true if successful, false otherwise.
• function TypeOf(const name: string): JSType;
  This method returns a JSType This is an enumerated type with the following possible values:
    JSTYPE_VOID
  JSTYPE_OBJECT
  JSTYPE_FUNCTION
  JSTYPE_STRING
  JSTYPE_NUMBER
  JSTYPE_BOOLEAN
  
  A JSTYPE_VOID value means the property or method does not exist. JSTYPE_NUMBER can indicate either an integer or a floating point value. Use TJSObject.IsInteger to determine whether it is an integer or floating point value. describing the property's data type.