Script Component File Contents

Windows® Script Component files are XML (Extensible Markup Language) that are much like HTML files, but contain special elements that define the script component and its behavior. The elements used for defining script components are not HTML tags, but are XML elements specifically used for script component definitions.

A basic script component file contains these elements:

<component> and <package> elements The <component> element encloses one entire script component definition. Multiple <component> elements can appear in the same .wsc file, and are contained within a master <package> element.
<registration> element Includes information used to register your script component as a COM component. This element might not be required if the host application (such as Microsoft® Internet Explorer 5.0) does not directly use the Windows registry when creating an instance of the script component.
<public> element Encloses definitions for properties, methods, and events that your script component exposes. The definitions point to variables or functions defined in a separate <script> block.
<implements> element Specifies the COM interface handler for the script component, which determines what type of COM component the script component will be. For example, by specifying <implements type=ASP>, you implement the ASP interface handler and therefore get access to the ASP object model in your script component.
The <public> element is used to specify that a script component implements the COM Automation interface handler. Therefore, you don't need to create an <implements> element for the Automation handler.
Note The script component run-time includes interface handlers for Automation (exposed using the <public> element), for ASP, and for Internet Explorer 5.0 DHTML Behaviors. Other interface handlers are available as external DLLs. For more information about additional interface handlers and script components, see the Microsoft Scripting Technologies Web site.
<script> element Contains the script used to implement the logic of your script component, depending on what type of COM component you are creating. For example, if you are creating a COM Automation component, you declare properties, methods, and events in a <public> element, and then write the script to define them in one or more <script> elements.
<object> element Contains information about an object that you use in your script, such as another COM component.
<resource> elements Contain values that should not be hard-coded into script component code. Resource elements can include information that might change between versions, strings that might be translated, and other values.
<reference> element References a type library you want to use in script.
<comment> elements Contain text that is ignored when the script component is parsed and executed.
Note If you are concerned that the .wsc files you create contain XML that conforms to XML standards, you can specify that the script component's XML parser check the XML syntax. For example, this is useful if you think you might someday use an XML editor to work with your files. Otherwise, however, it is not usually a concern. For more details, see Script Component Files and XML Conformance.

Skeleton Script Component File

The following example illustrates how to construct a script component file.

<?XML version="1.0"?>
<package>
<?component error="true" debug="true"?>

   <comment>
      This skeleton shows how script component elements are 
      assembled into a .wsc file.
   </comment>

<component id="MyScriptlet">
   <registration
      progid="progID"
      description="description"
      version="version"
      clsid="{00000000-0000-0000-000000000000}"/>

   <reference object="progID">

   <public>
      <property name="propertyname"/>
      <method name="methodname"/>
      <event name="eventname"/>
   </public>

   <implements type=COMhandlerName id=internalName>
      (interface-specific definitions here)
   </implements>

   <script language="VBScript">
      <![CDATA[
      dim propertyname
      Function methodname()
      ' Script here.
      End Function
      ]]>
   </script>

   <script language="JScript">
      <![CDATA[
      function get_propertyname()
      { // Script here.
      }
      function put_propertyname(newValue)
      { // Script here.
         fireEvent(eventname)
      }
      ]]>
   </script>

   <object id="objID" classid="clsid:00000000-0000-0000-000000000000">
   <resource ID="resourceID1">string or number here</resource>
   <resource ID="resourceID2">string or number here</resource>
</component>
</package>

Note In XML, you can specify elements without content (attributes only), such as the <property> and <method> elements in the previous example, by closing the element with />.

Note that:

The <?XML ?> declaration at the top indicates that this is an XML file and that it conforms to XML protocol. This declaration is optional; if you leave it out, you can use slightly looser syntax when creating the script component's elements. For details, see Script Component Files and XML Conformance.
The <package> element is optional in this example, because the file contains only one <component> element.
The <?component?> processing instruction includes attributes for specifying the error checking options. For details, see Checking For Errors in Script Component Files. If you do not include this element, the default options are all false.
A <comment> element can appear anywhere in the script component.
A <registration> element is not required in all cases. For example, a script component that implements the DHTML Behaviors interface handler in Internet Explorer 5.0 does not need to be registered, because Internet Explorer directly instantiates the behaviors as they are detected on the page. For details about registration requirements, see the documentation for the interface handler you are implementing, and note also which host the script component will be used in.
A <reference> element allows you to include a type library in the script component so you can use the library's constants in your script.
The <public> element encloses <property>, <method>, and <event> elements. The script that defines these appears later in the script component file.
The <implements> element is used to make available non-default COM interfaces. For example, you can expose the ASP interface with an <implements> type such as the following:
```
<implements type="ASP" id="iASP">
```
The exact elements that appear inside an <implements> element depend on what interface you are implementing.
Note The <implements> element is shown here with an id attribute. However, this attribute is optional, except in cases where you must disambiguate objects or variables. For details, see the <implements> element.
In this skeleton, there are two script elements, one for VBScript and one for JScript. If you are using only one scripting language, you do not need more than one <script> element. Because the <?XML ?> declaration appears at the top of the file, a CDATA section is required to make the script in the <script> element opaque. For details, see Script Component Files and XML Conformance.
The <object> element creates a reference to an object you want to use in script within the script component.

After creating the skeleton, fill in the elements to define the script component's functionality, depending on which interface handler you are implementing.

Script Component File Contents

Skeleton Script Component File

See Also