define-automation-component

define-automation-component Macro

Summary

Define an implementation class for a particular Automation component.

Package

com

Signature

define-automation-component class-name ({superclass-name}*) ({slot-specifier}*) {class-option}*

Arguments

`class-name`⇩	A symbol naming the class to define.
`superclass-name`⇩	A symbol naming a superclass to inherit from.
`slot-specifier`⇩	A slot description as used by defclass.
`class-option`⇩	An option as used by defclass.

Description

The macro define-automation-component defines a standard-class which is used to implement an Automation component. Normal defclass inheritance rules apply for slots and Lisp methods.

Each superclass-name argument specifies a direct superclass of the new class, which can be any standard-class provided that certain standard classes are included somewhere in the overall class precedence list. These standard classes depend on the other options and provide the default superclass list if none is specified. The following standard classes are available:

standard-i-dispatch is always needed and provides a complete implementation of the i-dispatch interface, based on the type information in the type library.
standard-i-connection-point-container is needed if there are any source interfaces specified (via the :coclass or :source-interfaces options). This provides a complete implementation of the Connection Point protocols.

slot-specifiers are standard defclass slot definitions.

class-options are standard defclass options. In addition the following options are recognized:

(`:coclass` `coclass-name`)
	`coclass-name` is a symbol specifying the name of a coclass. If this option is specified then a class factory will be registered for this coclass, to create an instance of `class-name` when another application requires it. The component will implement the interfaces specified in the coclass definition and the default interface will be returned by the class factory. Exactly one of `:coclass` and `:interfaces` must be specified.
(`:interfaces` `interface-name`*)
	Each `interface-name` specifies an Automation interface that the object will implement. The `i-unknown` and `i-dispatch` interfaces should not be specified because their implementations are automatically inherited from standard-i-dispatch. No class factory will be registered for `class-name`, so the only way to make instances is from with Lisp by calling make-instance. Exactly one of `:coclass` and `:interfaces` must be specified.
(`:source-interfaces` `interface-name`*)
	Each `interface-name` specifies a source interface on which the object allows connections to be made. If the `:coclass` option is also specified, then the interfaces flagged with the `source` attribute are used as the default for the `:source-interfaces` option. When there are event interfaces, the component automatically implements the `IConnectionPointContainer` interface. The supporting interfaces `IEnumConnectionPoints`, `IConnectionPoint` and `IEnumConnections` are also provided automatically.
(`:extra-interfaces` `interface-name`*)
	Each `interface-name` specifies a COM interface that the object will implement, in addition to the interfaces implied by the `:coclass` option. This allows the object to implement other interfaces not mentioned in the type library.
(`:coclass-reusable-p` `reusable`)
	If `reusable` is true (the default), then the server running the component can receive requests from more than one application. If `reusable` is `nil`, then the server will receive requests only from the application that started it and the Operating System will start a new instance of the server if required. For more details, see `REGCLS_MULTIPLEUSE` and `REGCLS_SINGLEUSE` in MSDN.
`(:type-library type-library-name)`
	`type-library-name` is a symbol specifying the name of a type library, mapped from the name given by the "library" statement in the IDL. If this option is specified then an error is signaled if the names used in the `:coclass`, `:interfaces` or `:source-interfaces` class options are not defined by `type-library-name`.

Use define-com-method, define-dispinterface-method or com-object-dispinterface-invoke to define methods in the interfaces implemented by the component. See also 1.9.4 Unimplemented methods.

Examples

(define-automation-component c-test-suite-1 ()
    ((prop3 :initform nil)
     (interface-4-called :initform nil))
  (:coclass test-suite-component)
  )